This document provides information about some of the software associated with the Tarpeeksi Hyvae Soft banner.
The document has been prepared using the dokki documentation framework.
| Primary language | Software count |
|---|---|
| C++ | 16 |
| JavaScript | 13 |
| C | 5 |
| Python | 3 |
| Assembly | 2 |
| Java | 1 |
| PHP | 1 |
| TypeScript | 1 |
| Primary category | Software count |
|---|---|
| Rendering | 11 |
| User interface | 4 |
| Visualization | 4 |
| Modding | 3 |
| Audio/video | 2 |
| Benchmark | 2 |
| Content management | 2 |
| Typing | 2 |
| Database | 1 |
| Data converter | 1 |
| Documentation | 1 |
| File format | 1 |
| Machine learning | 1 |
| Patch | 1 |
| Simulation | 1 |
| User experience | 1 |
| Uncategorized | 2 |
| Year of creation | Software count |
|---|---|
| 2021 | 3 |
| 2020 | 7 |
| 2019 | 11 |
| 2018 | 7 |
| 2017 | 4 |
| 2016 | 4 |
| 2015 | 2 |
| 2013 | 1 |
| 2012 | 1 |
| 2010 | 1 |
| 2003 | 1 |
A useful capture tool for Datapath's VisionRGB range of capture cards. Features a variable output refresh rate, anti-tearing, highly configurable image filtering, video presets with activation by resolution, refresh rate and shortcut, and several other things that enable high-quality analog and digital capture for recreational and professional use.
VCS supports capturing in Windows (XP and later) and Linux (kernel 5). Since it also has a low reliance on GPU features, VCS is highly compatible with virtualization software (tested to run in QEMU, VMWare Player, and VirtualBox). Fully virtualized capture via PCI passthrough in QEMU (Linux host, Windows XP and 7 guest) from a Datapath VisionRGB-PRO has been confirmed working.
VCS introduces minimal latency to the capture chain. The full latency from a visual event triggering in the target system to it being captured by a Datapath VisionRGB device, uploaded into system memory for VCS, and displayed in VCS's output window is typically in single-digit milliseconds for common VGA resolutions.
The VCS architecture runs a central execution loop which calls on functionality provided by its subsystems to capture, manipulate, and display frames obtained from the capture device. The subsystems are self-contained and provide a public interface both for using the subsystem and replacing it with another implementation of the interface. For example, support for new capture devices can be added by replacing the implementation of the capture subsystem interface.
VCS comes with fully custom GUI styling made using Qt's CSS-like QSS language.
Made in 2017–2021.
Links: GitHub • Download • User's manual • Developer's manual (work in progress)
| Vendor | Model |
|---|---|
| Datapath | VisionRGB-PRO1/PRO2 |
| Datapath | VisionRGB-E1/E2 |
| Datapath | VisionRGB-E1S/E2S |
| Datapath | VisionRGB-X2 |
| Version | Release date |
|---|---|
| 2.0.0 | April 2020 |
| 1.0.0 | March 2018 |
| Initial release (beta.1) | April 2017 |
Developer documentation for VCS, with fully custom Doxygen theming.
The docs are produced as in-code Doxygen-formatted documentation that's converted in an intermediate step into XML using Doxygen and finally into HTML using a custom XML-to-HTML converter.
The custom XML-to-HTML converter uses Python's ElementTree to load in Doxygen's XML files, then recursively iterates over the XML trees to convert them into HTML markup. The converter is designed with modularity in mind, using swappable components that produce HTML output from XML input and so allowing different output themes to be created separately of the converter.
Compared to Doxygen's standard HTML output, the custom theme includes light and dark mode, a mobile-friendlier layout (work in progress), more semantic HTML, and code markup that's compatible with the highlight.js syntax highlighter. Future features will include search functionality.
Made in 2020–2021. The original version, in 2020, was a re-skinning of Doxygen's pre-generated HTML using custom CSS and manipulation of the generated HTML files using Python's Beautiful Soup. The second version, in 2021, implemented fully custom output via processing Doxygen's XML into custom HTML/CSS/JavaScript.
Links: View the docs (work in progress) • GitHub (XML-to-HTML converter)
A simple command-line tool that shows the current output rate (frames per second) of a Datapath VisionRGB capture card. Useful for e.g. estimating the card's maximun capture rate while excluding external factors like host CPU/GPU speed. Works with cards that implement the RGBEasy API.
Made in 2017.
Links: GitHub
FPS on channel #0: 70
FPS on channel #0: 70
FPS on channel #0: 70
...
A well-featured, retro-oriented 3D software renderer for the HTML5 canvas. Rasterizes n-sided polygons onto a given canvas – or, optionally, into an offscreen pixel buffer.
This renderer features retro aesthetics; reasonable performance (for lower-resolution rendering); vertex and pixel shaders; affine and screen space texture-mapping; rasterization of points, lines, and n-sided convex polygons; flat, per-vertex (Gouraud), and per-pixel (Phong) shading; alpha testing; stippled alpha blending; 16-bit (RGBA/5551) and 32-bit (RGBA/8888) textures; texture mip-mapping; clamped and repeating UV coordinates with support for negative coordinates; wireframe rendering; translation, rotation, and scaling of vertices; async rendering using Web Workers; Blender export; unit, integration, and performance tests; a streamlined API; docs; samples; and more.
The renderer has no external dependencies. It uses a plain Bash script to bundle its source files into a single-file distributable, which can be imported either globally or as an ES6 module.
Made in 2019–2021.
Links: GitHub • Render samples • User's manual • API reference • Benchmark (heavy) • Benchmark (light)
Rngon.render_async([mesh]).then(result=>
{
canvas.getContext('2d').putImageData(result.image, 0, 0);
});
// The renderer will call this function for each n-gon following the lighting
// and world-space transformation steps but prior to rasterization.
function pulsing_vertex_shader(ngon)
{
const timer = (performance.now() / 900);
const pulseMult = Math.abs(Math.sin(timer));
for (let v = 0; v < ngon.vertices.length; v++)
{
ngon.vertices[v].shade = Math.max(0.5, (pulseMult * v));
}
}
// The renderer will call this function once the current frame has been rasterized.
// The 'fragmentBuffer' property contains metadata about each pixel, like world-
// space coordinates and n-gon material properties.
function wavy_pixel_shader({renderWidth, renderHeight, fragmentBuffer, ngonCache, pixelBuffer})
{
const timer = (performance.now() / 300);
for (let y = 0; y < renderHeight; y++)
{
const horMagnitude = 7;
const verMagnitude = ((y / renderWidth) * 10);
const cos = (horMagnitude * Math.cos(timer + verMagnitude));
for (let x = 0; x < renderWidth; x++)
{
const dstIdx = (4 * (x + y * renderWidth));
const srcIdx = (4 * (Math.min((renderWidth - 1), (x + horMagnitude + ~~cos)) + y * renderWidth));
const fragment = fragmentBuffer[srcIdx / 4];
if (!ngonCache[fragment.ngonIdx].material.isWavy)
{
continue;
}
pixelBuffer[dstIdx + 0] = pixelBuffer[srcIdx + 0];
pixelBuffer[dstIdx + 1] = pixelBuffer[srcIdx + 1];
pixelBuffer[dstIdx + 2] = pixelBuffer[srcIdx + 2];
pixelBuffer[srcIdx + 0] = 255;
pixelBuffer[srcIdx + 1] = 255;
pixelBuffer[srcIdx + 2] = 255;
}
}
}
| Benchmark result (FPS) | |||
|---|---|---|---|
| Browser | Heavy | Light | Wireframe | CPU: Ryzen 5000 series |
| Chrome 95 | 13 | 290 | 415 |
| Firefox 93 | 6 | 144 | 180 | CPU: Intel Haswell |
| Chrome 93 | 7 | 160 | 258 |
| Firefox 90 | 4 | 87 | 123 |
| Version | Release date |
|---|---|
| First beta release | December 2019 |
| First alpha release | January 2019 |
A wireframe renderer of arbitrary polygons whose render target is an <svg> image element.
The renderer works by re-populating the image element each frame. First, the element is emptied of the previous frame's contents via iterative calls to removeChild(), then <polygon> elements from a pre-generated cache are inserted and modified with the new frame's screen-space vertex coordinates.
The render performance is very adequate for single frames, but continuous rendering seems to suffer from stuttering.
This renderer is an offshoot of the retro n-gon renderer, sharing much of its API style.
Made in 2020–2021.
Links: GitHub • Interactive samples • Benchmark
| Benchmark result (FPS) | |||
|---|---|---|---|
| Browser | Quake (E1M1) | CPU: Ryzen 5000 series | |
| Chrome 95 | 395 | CPU: Intel Haswell | |
| Chrome 92 | 204 | ||
A handy HTML5-based visualizer for simple 3D n-gonal meshes, with an easy-to-use API and UI.
Possible use cases include debug visualization in the workflow of writing a mesh file importer, and for minimalist demonstration of the contents of a mesh file.
Uses Luujanko for the wireframe rendering. (The performance of the SVG-based Luujanko is somewhat sub-par for rendering large meshes, so it's possible that future versions of this app will migrate to WebGL or the like.)
Made in 2020–2021.
Links: GitHub • View some simple meshes • View some complex meshes
A web app for hobbyist birdwatchers to keep track of their sighted species in a visually engaging, slightly gamified way. Each sighting is represented as a card showing an image of the species along with the date of observation, while the total of observations made are presented as a list of these cards – usage of the program is then akin to card-collecting.
To make debugging and runtime error-reporting easier, as well as to improve the reliability of the program, Lintulista's JavaScript code enforces type checks with explicit runtime assertions, introduces underlying typing for custom objects via simple pseudo-inheritance, and provides a try/catch-wrapping action system that groups related commands toward a goal with the user-facing error messages associated with that goal's failure states.
Lintulista's backend is Heroku-compatible and makes an attempt to minimize the use of database rows – potentially useful for those on the limited Heroku Free plan. The backend provides unit tests, while the frontend implements React component tests.
The Lintulista repo comes with tooling to semi-automate the creation bird thumbnails from images on Wikimedia Commons.
Lintulista is for private use at this time, but a public sample is provided (see links, below).
Made in 2019/2021.
Links: View sample • GitHub (client) • GitHub (server)
A 3D front-end for the PC emulator PCem. PCbi replaces PCem's text-based user interface with a 3D scene in which you can assemble and run the emulated PCs.
Rather than clicking through plaintext menus to select which components an emulated PC should have, PCbi lets you stick components into a motherboard in a 3D view – making the assembly a more tangible, rewarding experience. Once the PC has been assembled, PCem can be made to run the emulation on its virtual screen.
PCbi implements real-time inter-process communication with PCem via shared memory (Linux and Windows). First, the PCem source code is modified accordingly to enable the communication, then two-way access into a byte array is established at run-time between PCbi and PCem. Specific control bytes are toggled by either program to let the other one know of changes in status, and data bytes carry particular payloads to the other process (e.g. the pixel data of PCem's screen buffer, to be displayed by PCbi on the screen of the virtual PC).
The program implements a connector interface for installing components into the virtual PC. For each connector (e.g. a female ISA slot on the motherboard and a corresponding male ISA card edge on a video card), a type and gender are assigned, which must match when attempting connection (supports multi-capable connectors, e.g. a female 16-bit ISA slot being also able to accept 8-bit ISA card edges). Each connector is also associated with two vectors: one pointing in the direction of plugging, and the other a common direction for aligning the two components when connecting. The vectors allow PCbi to properly rotate a component's 3D mesh to match the orientation of its parent when connecting. Early versions of PCbi supported a tree structure for component connections, where a component could be connected to a component connected to another component connected to a third component, etc. (e.g. inserting memory chips onto a video card installed in a motherboard); but later versions simplified this system for usability reasons to just allowing components on a motherboard.
On Linux, PCbi includes a very handy "shared folders" feature, which allows the user to select a folder on their hard drive and have its contents be made available in the emulated environment. This is achieved behind the scenes simply by creating an ISO file of the folder (using a system() call for genisoimage) and telling the PCem process to mount it.
The 3D renderer uses OpenGL for rasterization, with vertex transformation handled CPU-side (first versions of the app used full software 3D rendering). The program has a fully custom GUI styling made with Qt. Mouse picking in the 3D scene uses standard ray casting. Other features include the ability to set a background image for the 3D scene, and (on Linux) acquiring input lock in PCem by double-clicking the PC screen in PCbi.
Made in 2018–2021.
Links: Additional content • Dev playlist on YouTube
| Version | Release date |
|---|---|
| First non-beta (0.13.0) | May 2020 |
| Initial release (beta.1) | January 2018 |
My first path tracer. It served as a personal testbed in messing around with offline rendering.
This renderer featured photon mapping; spectral reflectance; volumetric rendering (subsurface scatter, clouds, snow); HDR environment mapping; ray–triangle intersection tests on the GPU; and various other things.
Made in 2010–2014.
Ever wanted a cloud physics simulator and renderer? Maybe not, but this app provides.
The program simulates the rising of moist air and the subsequent condensation of cloud-forming droplets as the air cools; then renders the resulting 3D droplet grid into a realistic image of clouds.
You can configure the simulator's atmospheric properties to your liking, including the environmental lapse rate and relative humidity curves. The GUI provides real-time visualization of the state of the simulation, showing the relative humidity, air temperature, and droplet distribution either as averages across the simulation grid or as horizontal or vertical slices.
The renderer uses volumetric path tracing and photon mapping to model in-cloud light transfer. Spectral Mie scattering is empirically approximated (by eyeballing MiePlot graphs), while the Hosek–Wilkie 2012 sky model is used to approximate Rayleigh scattering. Optionally, a HDR environment map can be used in place of the parametric sky model.
OpenCL is used to accelerate calculations of condensation (a square root and a multiplication or two per simulation grid cell, each cell being processable parallel to the others), while the renderer works on tiles distributed across the system's cores.
This program required a beefy computer. With a mid-to-low-range home PC of the time, running the simulation on a high-resolution grid (e.g. 300 × 300 × 300) could take hours, and the rendering would take several days to converge to a relatively noise-free outcome even at low render resolutions (e.g. 512 × 512).
Made in 2013–2014.
A multi-platform asset-editing toolset for the cult DOS game Rally-Sport. This toolset lets you create and edit tracks, textures, and various other aspects of the game. To my knowledge, it's the only available modding tool for this game.
Creating the RallySportED toolset required figuring out the game's data formats, and ways to allow custom content to be loaded into a game that doesn't natively support mods. The latter required some disassembly and patching of the game's executables, and the creation of a loader program that applies these patches at run-time.
Links: Some of the tracks I've made • Game data format reference
| Version | Release date |
|---|---|
| Browser version 1.0 | December 2020 |
| First release of the browser version | November 2018 |
| First release of the Win32 version | August 2018 |
| First release of the DOS version | April 2017 |
| Initial release (Linux/Windows) | November 2016 |
A version of RallySportED for modern browsers. It provides track and texture editors, as well as some handy extra features like a built-in DOSBox for playing Rally-Sport in the editor, and WebRTC data streaming for easy sharing of creations with friends.
The custom software 3D renderer in this version closely reproduces Rally-Sport's unique 3D rendering style, with n-sided polygons, screen-space texture-mapping, and one-point perspective. The renderer uses the retro n-gon renderer with custom transformation and rasterization paths.
This version of RallySportED integrates an in-browser DOSBox for previewing and playing your creations directly in the editor (sample). A similar feature is the ability to share your content from the editor to other people via WebRTC data streaming. The code implements WebRTC support using PeerJS to abstract away the WebRTC setup details and a custom streamer/viewer (or a one-to-many network) interface that wraps around PeerJS.
An undo/redo feature for user actions (editing the track terrain, painting textures, etc.) is implemented as a stack of action clusters, where each cluster represents a set of related actions (e.g. x pixels being modified by the user moving the mouse over a texture to paint a line) and stores information about which data changed (for redo) and the inverse of those changes (for undo). Since all user actions are channeled through an asset mutator object, it's simple to capture and group them for the undo/redo stack.
A closely related project is Rally-Sport Content, which provides a database for sharing RallySportED-made content and a REST API with which this browser version of RallySportED can fetch and display content from the database (sample).
Made in 2019–2021.
Links: Run in browser • GitHub
A version of RallySportED for Win32 platforms (Windows 95 and up). It gives the user tools for editing the game's tracks and track textures.
This version of the RallySportED toolset provides Windows support via the native Win32 API, is Wine-compatible (i.e. runs well in Linux), and comes with 3D hardware rendering using the legacy OpenGL 1.2 and Glide 3 APIs (with custom fallback software rendering available).
This is the only version of RallySportED with hardware 3D rendering – the other versions using pure software renderers. Subsequently, this is the only version of RallySportED that doesn't reproduce the distinct angle-dependent texture warping that results from the game calculating polygon texture coordinates in screen space.
The OpenGL and Glide renderers created for this app were later forked to become the basis for Kelpo.
Made in 2018.
A version of RallySportED for 16-bit DOS.
This DOS version of RallySportED is written mostly in 386 assembly (fasm syntax); and includes the loader program required for playing modded content in-game. The version also used to include track and texture editors, but they've since been deprecated in favor of the same functionality in the browser version of RallySportED (to avoid having to maintain the same features across multiple platforms).
Rally-Sport wasn't made with modding in mind, so it has no built-in functionality for loading in custom content. Instead, the DOS version of RallySportED provides a loader program that reads commands from a directive file telling it which content should be loaded, unpacks the content, and modifies the game's executables to inject the content into the game.
The DOS version also comes with a smart CPU opponent editor. Rally-Sport has a replay feature that stores and plays back the player's latest lap; so the opponent editor figures out where in memory the replay data are stored, patches the game executable to dump this region of memory to disk when the player completes a lap, then parses the memory dump to create a CPU opponent that mimics the player's lap for that track. It's then easy for a modder to make a CPU opponent for their new track: drive a lap around it and you're done.
Made in 2016–2020.
Links: GitHub
A platform for users of RallySportED to share and download custom content for Rally-Sport.
This platform provides both a back-end that stores RallySportED-made content (e.g. custom tracks) and a REST API through which clients can interact with the back-end, fetching and posting content. Also provided is a handy HTML view for accessing the API with a browser.
The implementation contains a custom MVC framework for creating views into the content, and a modular HTML builder for generating pages for the HTML view. Includes user accounts with registration, login, and password reset.
The database code includes a syntax abstraction layer that interprets a simple generic database language into the actual language of the database system used (e.g. a given variety of SQL), allowing the underlying database system to be changed with (in theory) only the syntax interpreter code needing to be adapted.
Made in 2020–2021.
Links: Run in browser • GitHub
Looks like an old browser, acts like an old browser. Serlain is a frontend for Internet Archive's Wayback Machine that displays archived pages inside period-correct-looking faux browsers, set on a faux period-themed desktop.
The app renders a browser as a HTML element with its background image a screenshot of a blank browser window (empty title bar, nothing in the address bar, etc.). The blank portions are then filled in with interactible React components positioned with CSS.
The code design is modular, so new (old) browsers can be added fairly easily – you'll find a basic example, below.
Made in 2019–2021.
Links: Run in browser • GitHub
const nn4 = {
desktopIcon: {
title: "Netscape Navigator 4",
imageUrl: "./img/icons/netscape-navigator-3.png",
},
browserClassName: "netscape-navigator-4 resolution-800x600",
// The year from which this browser will show Wayback Machine captures.
browsingYear: 1997,
// The desktop styling to be shown when this browser is open.
operatingSystem: "Windows 95",
// The standard interactible buttons available in this browser.
buttons: ["reload", "home", "back", "forward", "close"],
// Strings shown in the browser's message bar in response to events.
messageBarStrings: {
fetching_page_url: (url)=>`Connect: Looking up host: ${url}...`,
loading_page: (url)=>`Transferring data from ${url}`,
page_load_failed: (url)=>`Unable to connect to site ${url}`,
page_load_finished: ()=>"Document: Done",
},
};
A hybrid voxel/polygon 3D software renderer that gets its inspiration from retro voxel/polygon games like Delta Force and Outcast.
The voxel renderer makes 2D heightmaps into 3D landscapes. It's effectively a ray tracer, tracing a ray through each pixel on the screen and sampling height values from the heightmap along the ray's path. The renderer has full six degrees of freedom, multi-threading, and bilinear interpolation.
The polygon renderer supports single-threaded scanline and barycentric rasterization. It uses the depth map generated by the voxel renderer to discard pixels occluded by the terrain.
Made in 2018–2021.
Links: GitHub
A simplified port of Vond and a learner project in Java. Provides a heightmap-based software voxel renderer with full degrees of camera rotation. Comes with a relatively extendable OOP codebase and some unit tests.
Made in 2019.
Links: GitHub
Heightmap passed its unit test.
Texture passed its unit test.
Vector3 passed its unit test.
Screen passed its unit test.
TerrainRenderer.render(): Time to render: 94 ms (11 FPS).
TerrainRenderer.render(): Time to render: 29 ms (35 FPS).
TerrainRenderer.render(): Time to render: 20 ms (50 FPS).
Patches a bug/feature in Ultima 7 that forces the CPU cache on at launch.
Ultima 7 – like many programs of the time – will run too fast on PCs that are much newer than what the game was originally made for. A common workaround for this kind of problem is to soft-disable the CPU's cache, heavily reducing its performance and thus bringing it more in line with what the program expects.
Unfortunately, this workaround is no good for Ultima 7, because the game resets the cache-disabling CPU flag on launch. Bummer.
Luckily, this patch modifies the game executables so that they preserve the relevant CPU flag. As a result, the game can be run with the cache off.
Thanks to a member (whose name is unfortunately forgotten) of the VOGONS forum for discovering that the bug had to do with the game resetting CPU flags.
Made in 2017.
Links: GitHub
U7DCP - Ultima VII DOS Cache Patch.
Patching MAINMENU.EXE...
Patching ENDGAME.EXE...
The patching appears to have gone well.
; The game wants to enable protected mode as the first step in entering
; unreal mode. Normally, it assigns 1 to EBX, which sets the relevant
; first bit but also resets all the other bits (importantly, bit #30,
; for cache disable). Instead, we want to set only the first bit and
; leave the others untouched.
mov ebx, cr0
or bl, 1
mov cr0, ebx
; ...
; The game has entered unreal mode and is ready to disable protected
; mode. Again, we want to manipulate only the relevant first bit.
and bl, 0feh
mov cr0, ebx
A set of command-line tools for converting data from the DAT files of Grand Prix Legends into more standard formats.
The tools can selectively extract files from DATs, convert MIPs and SRBs into PNG and 3DOs into OBJs. There's currently no option for inserting data back into a DAT, though.
I wrote these tools to help generate scenes for testing the retro n-gon renderer.
Made in 2019.
Links: GitHub
A documentation framework for creating end-user-oriented single-page docs. This website is made with it!
Dokki works as an extension of HTML, providing both custom markup tags like <dokki-code> and a content-structuring layer on top of the HTML: the user splits their content into <dokki-topic> elements, which are organized by dokki into a navigable single-page document. The document comes with an auto-populated navbar, responsive styling, and an optional dark mode.
This framework is work in progress.
Made in 2021.
Links: GitHub • API reference • Sample document
Topics are made up of normal HTML...
This C program prints “Hello there”.
// Hello there.
int main(void)
{
printf(``Hello there\n``);
return 0;
}
A streamlined, retro-oriented Win32 3D rasterizer API wrapper.
The idea behind Kelpo is to create an easy-to-use umbrella render API that exposes a minimal unifying feature set to cover as many 1990s 3D APIs/hardware as reasonably possible and producing generally the same output image regardless of which render platform is being used. (The 1990s, you may recall, saw a relative lack of 3D rendering standards and a wild west of video card feature-sets – see e.g. vintage3d.org for more info.)
Kelpo is work-in-progress (there's no hurry to complete it), and currently supports Direct3D 5, Direct3D 7, OpenGL 1.1, OpenGL 3.0, and Glide 3. Planned support includes the proprietary 3D APIs of Matrox, S3, and ATi.
Made in 2019–2020.
Links: GitHub
// Initialize Kelpo for OpenGL 1.1.
const struct kelpo_interface_s *kelpo = NULL;
kelpo_create_interface(&kelpo, ``opengl_1_1``);
// Open a 640 x 480 (16-bit) render window on video device #0.
kelpo->window.open(0, 640, 480, 16);
// Run the render loop.
while (kelpo->window.process_messages(),
!kelpo->window.is_closing())
{
kelpo->rasterizer.clear_frame();
kelpo->rasterizer.draw_triangles(&triangle, 1);
kelpo->window.flip_surface();
}
A binary file format for storing 3D models and their textures; a companion format for the Kelpo renderer. Designed with limitations of 1990s 3D hardware in mind.
A KAC file stores vertices, normals and UV coordinates in 32-bit floats. Texture data are stored in 16-bit color with transparency (RGBA4444); polygon colors are stored in 16 bits with alpha (RGBA5551). Textures are stored with mipmapping down to 1×1. Because a KAC file includes the model's entire set of textures, each texture is associated with a 128-bit SHA-256 pixel data hash to allow duplicate textures to be discarded when loading multiple KAC files.
Includes a C89-compliant importer for loading KAC meshes into C/C++ programs, and an OBJ-to-KAC mesh converter. The converter automatically generates texture mipmaps, resizes textures to the required power-of-two aspect ratio, and converts colors into KAC's native 16-bit format.
Made in 2019–2021.
Links: Spec (draft for v1.0) • GitHub
A HTML5 video player whose seek bar shows an expandable spectrogram of the video's audio. This is effectively a feature-optimized browser version of AV Scissors.
Samples the output of a <video> element using an AnalyserNode to produce a time-variant spectrum (audio spectrogram), then paints it onto a <canvas> on the video's seek bar.
This app was originally made for a friend who had a need for it, but it turned out their iPad was overly paranoid about letting the browser access videos on the system, and so they couldn't use this.
Made in 2020.
Links: Run in browser • GitHub
A simple path tracer that can be compiled to run on the Game Boy Advance. Its code also compiles for desktop platforms. Since path tracing is very computationally expensive and slowray contains no optimizations to compensate, it runs extremely slow on the GBA's hardware.
Made in 2016, 2019.
Links: GitHub
A vanilla multi-threaded path tracer in JavaScript/TypeScript.
Features cosine-weighted Lambertian sampling, scene importing from Blender, exporting renderings into PFM, continuing previous renderings from PFM, multi-threaded rendering, tone mapping, normal interpolation, a BVH tree to accelerate ray–triangle intersection tests, a JSON scene file format, and a functional coding style.
The Blender exporter saves the scene's camera location and direction, allowing the view to be composed in Blender and rendered as-is.
Made in 2019–2021.
Links: Run live sample • GitHub
{
"camera":{
"position":{"x":0,"y":0,"z":1.745841},
"axisAngle":{"x":0,"y":1,"z":0,"w":0}
},
"sky":{
"model":"cie-overcast",
"zenithDirection":{"x":0,"y":1,"z":0}
},
"materials":{
"default":{
"type":"lambertian",
"color":{"r":0.1,"g":1,"b":0.1}
}
},
"triangles":[
{
"material":"default",
"vertices":[
{"position":{"x":-2.653676,"y":-2.627338,"z":-8.797296},"normal":null},
{"position":{"x":2.666877,"y":-2.627337,"z":-8.797296},"normal":null},
{"position":{"x":2.666877,"y":-2.627338,"z":-14.179447},"normal":null}
]
}
]
}
| Worker count* | Render performance (1000 samples/sec.)† | |
|---|---|---|
| 1 | 40 | |
| 2 | 80 | |
| 3 | 100 | |
| 4 | 110 | |
|
* In Chrome 91 on a quad-core Intel Haswell CPU.
† Rendering this scene. Values rounded to nearest multiple of 10. |
||
Test your old processor's floating-point performance with this DOS path tracer that renders a scene of spheres and counts the number of seconds it took. A 486-66 will get it done in about six minutes, a Pentium 90 in 160 seconds or so, and the Xeon E3-1230 in less than one second.
The program runs in VGA mode 13h (320 × 200, 256 colors) and renders its test image in 120 × 80 resolution (upscaled to 240 × 160 for display). The scene to be rendered is made of eight spheres (five diffuse Lambertian and three reflective) and a large triangle for the ground plane; the background is a light source approximating the CIE Standard Overcast Sky.
Requires a math co-processor.
Made in 2017.
| Result (seconds to render) | CPU |
|---|---|
| 4 | AMD Athlon 64 X2 5050e |
| 7 | AMD Athlon XP 2200+ |
| 9 | Intel Celeron 2.4 |
| 37 | Intel Atom N270 |
| 47 | AMD K6-2 300 |
| 165 | Intel Pentium 90 |
A learner project in Python by way of a simple ray tracer. Comes with a fairly clean, small, extendable OOP codebase. Uses PyQt to export the rendering into a PNG image.
Made in 2020.
Links: GitHub
A program to measure your typing speed in detail. Provides statistics like percentage of mis-presses for each key, breakdown of typing time per key, and other stats of that kind. Also has a cool custom GUI made with Qt.
Made in 2015.
My learner app in React. Fetches weather forecasts from the Finnish Meteorological Institute's open data API and displays them as cards. Comes with a clean UI.
From this learner app, I moved to my second React project, the considerably more advanced Lintulista.
Made in 2019.
Links: GitHub • Run in browser
A transcription app with a minimalist UI, syntax error highlighting, audio playback, and some other things.
The original version of this program was written for a personal need in the space of a few days. It did the business but the codebase was messy; I eventually opted for a rewrite to make it more open-sourcable.
The project is currently on hold, as I don't need a program like this at the moment nor do I have a target audience in mind to market it to.
Made in 2018.
Links: GitHub (a rewrite)
A Qt-based video player whose timeline highlights the parts of the video that contain movement or sounds. Useful for pet surveillance and that sort of thing. You may find that the program works well for some videos and less well for others; typically, a suitable recording has good image and audio quality with little background noise.
Made in 2018.
Links: GitHub
My first project in JavaScript, after a decade or two of hobbyist C++. Renders spinning 3D cubes using three different techniques of rasterization.
I developed the browser version of RallySportED – my second project in JavaScript – right after this one. The basic render framework of this project was used as a starting point for the renderer in the browser version of RallySportED, which in turn was later forked to become the retro n-gon renderer.
Made in 2019.
Links: GitHub • Run in browser
My first ray caster, from 2003. Its initial incarnation was based quite heavily on Permadi's (then-)famous ray-casting tutorial.
This renderer evolved from a standard Wolfenstein-style 90-degree-walled caster into a heightmap-based 2.5D voxel renderer as I kept experimentally tinkering with it.
In about 2005, I moved away from this project and into other kinds of programming. Eventually, after playing around with it some more in 2008–2009, I started working on my first ray tracer, which quickly evolved into Yqr.
Vond is a more recent heightmapped voxel renderer.
Made in 2003–2005, 2008–2009.
An early webdev effort of mine. The goal was to re-design Gona's very useful but somewhat hard-to-read DOS video chip compatibility matrix (see link, below) for improved usability.
I harvested the matrix's HTML data, converted it into a JSON format, and implemented a front-end to provide a structured view to the data. The view shows the user an overall compatibility score for each video chip, lists the chips by most compatible to least compatible, and allows the user filter the results list by chip or manufacturer name.
Made in 2018.
Links: Original matrix
A simple 16-bit 3D rasterizer benchmark for recreational perf-testing of DOS-based C compilers. Compatible with a number of legacy C toolchains, such as from Microsoft, Borland, and HI-TECH.
The benchmark renders a spinning sphere in VGA mode 13h, then provides simple characteristics of its runtime performance.
Given the results (table, below), it seems that Microsoft's C/C++ compiler version 8 (as shipped with Visual C++ 1.5) is in a league of its own. At least when running the benchmark in DOSBox on the desktop.
Made in 2018.
Links: GitHub
| Result (FPS) | Compiler |
|---|---|
| 57 | Microsoft C/C++ 8 |
| 41 | Digital Mars C/C++ 8 |
| 37 | Open Watcom C/C++ |
| 33 | Borland Turbo C 2 |
| 32 | Borland C++ 2 |
| 32 | Microsoft C 5 |
| 31 | Microsoft QuickC 1 |
| 30 | HI-TECH Pacific C 7 |
| 14 | Mix Power C 2 |
A tool to make impulse response recordings into waterfall graphs.
The app reads WAV files representing impulse responses, uses the Kiss FFT library to extract the audio's frequencies in the time-domain, and renders the resulting spectrogram.
The method of rendering varied from ray tracing a 3D mesh of the spectrogram to drawing slices of the spectrogram as polygons using Qt's QPainter.
Made in 2012–2013.
A simple user interface for js-dos, intended primarily as a means to embed and demonstrate Tarpeeksi Hyvae Soft's DOS apps in this document.
The app provides a JavaScript API for defining a set of containerized DOS programs; a URL hash interface for running one of the containerized programs in js-dos (e.g. //localhost:80/dosbox/#quake); and a styled HTML container for the js-dos canvas with dynamic resizing that maintains the pixel aspect ratio.
The app was built for embedding and showcasing DOS apps on web pages – namely, DOS apps I've made, in this document (see e.g. DOS path tracing benchmark).
Made in 2021.
Links: GitHub
"quake": {
title: "Quake",
zip: "./content/quake.zip",
run: "quake.exe",
}
A no-frills database and grapher for minimalist logging of sequential data.
The database, loosely termed, is a headerless binary file consisting of 12-byte time/value pairs: a 4-byte float that stores a value logged on an occasion, and an 8-byte int that records the time – in milliseconds since epoch ‐ of the occasion. The database provides a simple command-line interface for entering and fetching data.
The grapher produces no-nonsense visual readouts of data from databases.
This program was purposefully written to conform to feature minimalism: it has a small set of base features, enough to do the intended business, and is to receive no new features regardless of post-creation needs.
Made in 2016, 2019.
Links: GitHub
A utility to turn hard drive SMART logs (i.e. output dumps from smartctl) into nice little graphs.
Provides a configuration file with which the user can customize the generated imagery. Graphs can be arranged into customized rows and columns, and simple mathematical expressions can be given to modify the logged values for output (e.g. to convert Celsius → Kelvin).
The program uses Qt to draw the graphs and for exporting them into PNG image files.
A more recent version of this program is Smarse.
Made in 2015.
# Attribute Graph size Graph X,Y Value Expression(s) C-Window Range Title
#---------------------------------------------------------------------------------------------------------
241 HALF 1,1 RAW a*0.000477 1 0 WRITES, MB PER HOUR
241 QUARTER 1,2 RAW a*0.000000477, a/1024 p300 0 TOTAL WRITES, TB
190 QUARTER 2,2 RAW a+273.15 0 0 TEMPERATURE, °K
A simplified version of Smartti parseri done using a web stack instead of C++/Qt.
The app reads SMART attribute data from smartctl log dumps via a Node.js back-end and converts the data using client-side JavaScript into SVG plots for display.
The fundamental output of the app is a single plot of a SMART attribute's values over a period of time (c.f. sample plot declaration, below). The user is free to style and composite these plots onto a web page as they see fit.
Made in 2021.
{
"queryTimeRange": {
"days": 1,
"start": 1628389623,
"end": 1628476023
},
"attribute": {
"idx": 9,
"name": "Reallocated Sector Ct",
"data": [
{
"time": 1628391601,
"value": 86,
"valueThreshold": 0,
"rawValue": 66018
},
{
"time": 1628402401,
"value": 86,
"valueThreshold": 0,
"rawValue": 66021
}
]
}
}
A feed-forward neural net with customizable layering. Learns the MNIST digits to about 97%. Various standard activation functions are available.
This program was written from scratch (without frameworks) as a learner project in machine learning.
Made in 2016.
Links: GitHub
Initializing for MNIST...
Net: Topology: N784-L10-S10
Learning rate: 0.010000
Training epochs: 3
Training on MNIST (60000/10000)...
Epoch 1 of 3: train = 68.947%, validate = 0.000%.
Epoch 2 of 3: train = 90.213%, validate = 90.300%.
Epoch 3 of 3: train = 91.570%, validate = 90.770%.
Training finished.
<Press ENTER to start the quiz, or CTRL+C to quit.>
.***####*
.*##**....
.*#####.
.##**#.
.#*
.*
**
#*
*#*.
.*##**.
..###*.
.*##*.
.*#*
.#*
.. .#.
.# .#.
#*. *#.
.##*. .#*
*###**####.
.**#**
The net guesses 5. That's correct.