This page provides information about some of the software associated with the Tarpeeksi Hyvae Soft / leikareipa banner. Binaries are currently unavailable, but the code is by and large open-source.
A useful capture tool for Datapath's VisionRGB range of capture cards. Features anti-tearing, advanced 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.
Implements fully custom-designed GUI styling with Qt/QSS. Subclasses several Qt components for custom functionality. Manages a multi-threaded context to synchronize hardware and software. Allows creating complex chains of image filters with a node graph. Outputs in software and OpenGL (supports variable refresh rate). Leverages Qt for HTML/CSS-stylable capture overlays. Supports capturing in Windows (XP and up) and Linux (5.x). Low reliance on GPU features; can run virtualized in QEMU, VMWare, and VirtualBox.
Although made for Datapath's capture cards, VCS's code provides an abstract capture interface through which support for other manufacturers' hardware (or other sources of image data) can be added. Find out more in the developer docs.
Includes an end-user's manual (GitHub Markdown) and code-level developer documentation (Doxygen with custom CSS theming).
Made between 2017-2021.
Tech used: C++, Qt, OpenCV, RGBEasy, Video4Linux, Doxygen
Links: GitHub • User's manual • Developer docs (work in progress)
| Vendor | Model |
|---|---|
| Datapath | VisionRGB-PRO1/-PRO2 |
| Datapath | VisionRGB-E1/-E2 |
| Datapath | VisionRGB-E1S/-E2S |
| Datapath | VisionRGB-X2 |
| Time | Version |
|---|---|
| April 2020 | 2.0.0 |
| March 2018 | 1.0.0 |
| April 2017 | beta.1 (first release) |
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 225 | 4364 | 3340 | 18329 |
| C++ | 103 | 3006 | 1415 | 11688 |
| C/C++ Header | 109 | 1358 | 1925 | 3431 |
| Qt | 13 | 0 | 0 | 3210 |
A unique 3D frontend for the PC emulator PCem. Assemble an olden PC in a 3D environment and have PCem's emulation run on its screen.
Implements shared memory communication with PCem in Linux and Windows. Originally used full software 3D rendering (barycentric rasterization) but now has software transform + OpenGL rasterization. Custom-styled Qt GUI. Moddable: tooling and documentation is provided for creating and adding new hardware components.
Made between 2018-2021.
Tech used: C++, Qt, OpenGL, JavaScript, Blender
Links: Additional content • Dev playlist on YouTube
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 75 | 2125 | 1056 | 9007 |
| C++ | 32 | 1564 | 859 | 6317 |
| Qt | 4 | 14 | 0 | 1611 |
| C/C++ Header | 39 | 547 | 197 | 1079 |
A full-stack web app for hobbyist birdwatchers to keep track of their sightings. Used to be publically available but is currently closed-access; the code is open-source and a public sample is provided (see links, below).
The code enforces type checks, implements pseudo-inheritance with underlying typing for custom objects and uses a try/catch-wrapping action system to make debugging and end-user error-reporting easier and less verbose to write.
The backend is Heroku-compatible and conserves database rows – useful for those on the limited Heroku Free plan.
Unit tests are implemented for the backend; the frontend implements React component tests (but see beta.2 release notes).
Comes with tooling to semi-automate the creation of copyright info-preserving bird thumbnails from images on Wikimedia Commons.
Made in 2019/2021.
Tech used: JavaScript, React, Node.js, PostgreSQL, C++, Qt, CSS
Links: View sample • GitHub (client) • GitHub (server)
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 61 | 1163 | 860 | 5617 |
| JavaScript | 29 | 409 | 367 | 1951 |
| JSX | 20 | 399 | 423 | 1557 |
| CSS | 5 | 237 | 5 | 1556 |
| C++ | 3 | 75 | 30 | 242 |
| Qt | 1 | 0 | 0 | 203 |
| C/C++ Header | 2 | 30 | 13 | 59 |
| PHP | 1 | 13 | 22 | 49 |
A well-featured retro-oriented 3D software renderer for the HTML5 canvas. Rasterizes n-sided polygons onto either a canvas or an offscreen buffer.
Features genuine retro aesthetics, reasonable performance, vertex and pixel shaders, async rendering, modular design, streamlined API, docs, lots of samples, a Blender exporter, and more.
The project depends on no extra packages or package managers, and uses a plain Bash script to bundle the source files into a single-file distributable that can be imported either globally or as an ES6 module.
Unit, integration and performance tests are provided.
Made between 2019-2021.
Tech used: JavaScript
Links: GitHub • User's manual • API reference • Benchmark (heavy) • Benchmark (light) • Benchmark (wireframe)
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 | |||
|---|---|---|---|
| Browser * | Heavy † | Light † | Wireframe † |
Chrome 91
|
6 | 156 | 251 |
Firefox 89
|
4 | 87 | 121 |
|
* In Linux on a quad-core Intel Haswell CPU.
† Frames per second (average of three runs). |
|||
| Time | Version |
|---|---|
| December 2019 | beta.1 |
| January 2019 | alpha.1 |
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 22 | 508 | 587 | 2375 |
| JavaScript | 20 | 485 | 527 | 2202 |
| PHP | 1 | 13 | 21 | 92 |
| Python | 1 | 10 | 39 | 81 |
Looks like an old browser, acts like an old browser - and almost is one. Serlain is a frontend for Internet Archive's Wayback Machine that displays archived web content inside period-correct-looking faux browsers. Set on a faux period-themed desktop.
Made between 2019-2021.
Tech used: JavaScript, React, CSS
Links: Run in browser • GitHub
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 33 | 494 | 312 | 2277 |
| CSS | 14 | 170 | 0 | 1248 |
| JSX | 13 | 180 | 184 | 535 |
| JavaScript | 5 | 121 | 79 | 408 |
| PHP | 1 | 23 | 49 | 86 |
A multi-platform asset-editing toolset for the cult DOS game Rally-Sport. RallySportED lets you create and edit tracks, textures, and various other aspects of the game. Currently focused on running in the browser (RallySportED-js), but over the years there have been native versions for DOS, Windows, and Linux.
The browser version of the toolset fully reproduces the game's unique software-rendered 3D graphics. It also allows modded content to be played directly in an in-browser DOSBox, and comes with WebRTC data streaming to easily share your creations with friends.
The Windows version (now deprecated) supported Windows 95 and up (Wine-compatible), and provided 3D rendering via OpenGL, Glide, and software.
The 16-bit DOS version (now deprecated, except for the backend) was written in assembly and C/C++, and could run on 386-class PCs (486 or Pentium recommended).
Made between 2016-2021.
Tech used: JavaScript, 386 assembly, C, C++, IDA
Links: Run in browser • GitHub (frontend) • GitHub (backend)
| Time | Version |
|---|---|
| December 2020 | 1.0 for browsers |
| November 2018 | First release for browsers |
| August 2018 | First release for Windows 95 |
| April 2017 | First release for 16-bit DOS |
| November 2016 | First public release (Linux/Windows) |
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 139 | 4583 | 4758 | 18116 |
| C++ | 39 | 1831 | 1200 | 7114 |
| JavaScript | 49 | 1525 | 1349 | 6272 |
| Assembly | 20 | 731 | 1946 | 3384 |
| C/C++ Header | 30 | 450 | 261 | 982 |
| CSS | 1 | 46 | 2 | 364 |
A platform for users of RallySportED to share content they've made.
Provides a REST API for client queries, implements a componentized MVC framework to create views into the backend data, and comes with a handy frontend view. Has user accounts with registration, login, and password reset. Smart auto-generation of track minimaps in SVG based on the track's CPU opponent's driving line.
Temporarily unavailable live.
Made in 2020.
Tech used: PHP, CSS
Links: GitHub
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 103 | 1327 | 1610 | 5941 |
| PHP | 83 | 1198 | 1593 | 5056 |
| CSS | 19 | 126 | 8 | 864 |
| JavaScript | 1 | 3 | 9 | 21 |
Ever wanted a cloud physics simulator and renderer? Maybe not, but Ifu provides. Condensation from moist rising air is simulated and rendered into realistic images of clouds. You can configure the atmospheric properties as you like and view the state of the simulation as it runs. Naturally simulates various cloud effects like pilei.
Empirically approximates spectral Mie scattering. Adopts the Hosek–Wilkie 2012 sky model to approximate Rayleigh scattering. Uses volumetric photon mapping to speed up the rendering of in-cloud sunlight.
Requires a beefy computer and some knowledge of cloud-related atmospheric processes.
Made between 2013-2014.
Tech used: C++, Qt, OpenCL
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 75 | 6697 | 8262 | 24528 |
| C++ | 34 | 5402 | 7291 | 19650 |
| C/C++ Header | 34 | 1158 | 836 | 3718 |
| Qt | 4 | 2 | 0 | 777 |
| OpenCL | 3 | 135 | 135 | 383 |
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. One way around this is to disable the CPU's cache, heavily reducing its performance and thus making it more compatible with the game.
Unfortunately, Ultima 7 also uses the somewhat uncommon unreal memory addressing mode, and apparently unnecessarily resets all CPU flags while entering this mode. Since the flags include the 'CPU cache off' bit, resetting them will (re-)enable the CPU cache, making it impossible to actually run the game with the CPU cache off.
This patch modifies the game's executables so that they preserve the value of the CPU cache bit. The CPU cache can then remain off and the game will run quite well even on modern CPUs – provided that the PC also has a compatible sound card.
Thanks to a member (name forgotten) of the VOGONS forum for discovering that the bug had to do with the game resetting CPU flags.
This app is written against the multi-platform fasm assembler and should be fairly straightforward to build from source.
Made in 2017.
Tech used: 386 assembly, IDA
Links: GitHub
U7DCP - Ultima VII DOS Cache Patch.
Patching MAINMENU.EXE...
Patching ENDGAME.EXE...
The patching appears to have gone well.
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 3 | 54 | 147 | 321 |
| Assembly | 3 | 54 | 147 | 321 |
The first ray/path tracer I made, serving as a personal testbed in offline rendering. Had naive implementations of volumetric photon mapping, spectral reflectance, subsurface scattering, environment mapping, and various other things. Could render volumetric effects like fog, snow, and clouds. Supported running ray–triangle intersection tests on the GPU with OpenCL.
Made between 2010-2014.
Tech used: C++, Qt, OpenCL
A vanilla JavaScript path tracer.
Features basic cosine-weighted Lambertian diffuse reflection, importing scenes from Blender, exporting renderings into PFM, continuing previous renderings from PFM, multi-threaded tracing, tone mapping, a BVH tree to accelerate ray–triangle intersection testing, and a JSON scene file format.
Made between 2019-2020.
Tech used: JavaScript
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.) | Performance delta |
|---|---|---|
| 1 | 41 | – |
| 2 | 78 | +90% |
| 3 | 100 | +28% |
| 4 | 109 | +9% |
| * In Google Chrome 91 on a quad-core Intel Haswell CPU. | ||
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 20 | 377 | 489 | 1659 |
| JavaScript | 20 | 377 | 489 | 1659 |
A streamlined SVG wireframe renderer of arbitrary polygons for the HTML5 canvas. No external dependencies; easy to integrate into an existing JavaScript project. Includes polygon clipping and rotation, and comes with a sample implementation of a first-person camera.
Made in 2020.
Tech used: JavaScript
Links: GitHub • View interactive samples
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 11 | 151 | 142 | 534 |
| JavaScript | 11 | 151 | 142 | 534 |
A documentation framework for creating end-user-oriented single-page docs. This website is made with it.
Dokki is currently work in progress.
Made in 2021.
Tech used: JavaScript, Vue.js, CSS
Links: GitHub • Run render test • API reference • Sample document
A streamlined retro-oriented Win32 3D rasterizer API wrapper written in C89. The idea is to create an easy-to-use master API that exposes a minimal unifying feature set which in other words produces as feature-identical an output as reasonably possible on as many 1990s 3D cards as reasonably possible.
Currently supports rendering with Direct3D 5 & 7, OpenGL 1.1 & 3.0, and Glide 3. Planned support includes the proprietary 3D APIs of Matrox, S3, and ATi.
Made between 2019-2020.
Tech used: C, OpenGL, Direct3D, Glide
Links: GitHub
const struct kelpo_interface_s *kelpo = NULL;
kelpo_create_interface(&kelpo, ``opengl_1_1``);
kelpo->window.open(0, 640, 480, 16);
while (kelpo->window.process_messages(),
!kelpo->window.is_closing())
{
kelpo->rasterizer.clear_frame();
kelpo->rasterizer.draw_triangles(&triangle, 1);
kelpo->window.flip_surface();
}
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 71 | 1562 | 1108 | 5566 |
| C | 34 | 1217 | 553 | 4756 |
| C/C++ Header | 37 | 345 | 555 | 810 |
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.
An importer (for loading KAC meshes into C/C++ programs) and exporter (for converting OBJ models into KAC meshes) are provided. The exporter automatically generates texture mipmaps and converts pixel colors into 16-bit.
Made between 2019-2020.
Tech used: C, C++, Qt
Links: Spec (1.0 draft) • GitHub
A HTML5 video player whose seek bar shows a spectrogram of the video's audio.
Samples the output of a <video> element with an AnalyserNode to produce a time-variant spectrum (audio spectrogram) that's painted onto a <canvas> on the video's seek bar.
Made in 2020.
Tech used: JavaScript, Vue.js
Links: GitHub
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 4 | 51 | 73 | 230 |
| JavaScript | 4 | 51 | 73 | 230 |
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, etc. Also has a cool custom GUI made with Qt.
Made in 2015.
Tech used: C++, Qt
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 21 | 1009 | 408 | 4865 |
| C++ | 9 | 816 | 383 | 3107 |
| Qt | 4 | 0 | 0 | 1296 |
| C/C++ Header | 8 | 193 | 25 | 462 |
A transcription app/IDE with a streamlined UI, error highlighting, and playback of raw audio. I used it commercially at some point.
Made in 2018.
Tech used: C++, Qt
Links: GitHub (rewrite)
Turns hard drive SMART logs into graphs. Has its own simple scripting language to combine and process various SMART attributes' values.
Made in 2015.
Tech used: C++, Qt
A hybrid voxel/polygon 3D renderer that runs on the CPU. Draws inspiration from old voxel-based games like Delta Force and Outcast.
The voxel renderer works on 2D heightmaps and has full degrees of freedom, multi-threading with OpenMP, and bilinear interpolation of height and texture data. The polygon renderer supports single-threaded scanline and barycentric rasterization. The two renderers operate on the same depth map, first populated by the voxel renderer and then the polygon one.
Made between 2018-2020.
Tech used: C++
Links: GitHub
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 36 | 595 | 442 | 2015 |
| C++ | 12 | 330 | 251 | 1182 |
| C/C++ Header | 24 | 265 | 191 | 833 |
A learner project in Python; or in other words a PyQt app for viewing high-dynamic-range PFM images. Includes custom PFM loading and a porting from C to Python of Frédéric Drago's implementation of his 2003 tone-mapping algorithm.
Made in 2020.
Tech used: Python, PyQt
Links: GitHub
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 4 | 86 | 58 | 377 |
| Python | 3 | 86 | 58 | 223 |
| Qt | 1 | 0 | 0 | 154 |
A little learner project in React. Fetches and displays weather forecasts from the Finnish Meteorological Institute's open data API.
Made in 2019.
Tech used: JavaScript, React
Links: GitHub • Run in browser
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 7 | 41 | 77 | 265 |
| JSX | 6 | 25 | 51 | 188 |
| JavaScript | 1 | 16 | 26 | 77 |
A set of cross-platform command-line tools for converting data from the DAT files of Grand Prix Legends into more standard formats. Can selectively extract files from DATs, export MIPs and SRBs into PNG, and convert 3DOs into OBJs.
Made in 2019.
Tech used: C++, PHP
Links: GitHub
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 19 | 598 | 420 | 2006 |
| C++ | 5 | 287 | 85 | 993 |
| PHP | 3 | 146 | 161 | 547 |
| C/C++ Header | 11 | 165 | 174 | 466 |
A cross-platform command-line tool to extract 3D models (into OBJ) and paletted textures (into PNG) from Tomb Raider 1's PHD files.
Made between 2019-2020.
Tech used: C, PHP
Links: GitHub
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 3 | 229 | 158 | 987 |
| C | 1 | 157 | 105 | 657 |
| PHP | 2 | 72 | 53 | 330 |
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.
Tech used: C
Links: GitHub
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 1 | 89 | 29 | 339 |
| C | 1 | 89 | 29 | 339 |
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.
Tech used: C++, Qt
Links: GitHub
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 20 | 496 | 371 | 1724 |
| C++ | 9 | 330 | 295 | 1270 |
| C/C++ Header | 10 | 166 | 76 | 332 |
| Qt | 1 | 0 | 0 | 122 |
A feed-forward neural net with customizable layering. Learns the MNIST digits to about 97%, depending on the settings provided. Written from scratch.
Made in 2016.
Tech used: C++
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.
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 13 | 316 | 217 | 1007 |
| C++ | 6 | 200 | 99 | 773 |
| C/C++ Header | 7 | 116 | 118 | 234 |
My first project in JavaScript. Renders spinning 3D cubes with three different techniques of rasterization. This project was later developed into the much more advanced retro n-gon renderer.
Implements unit tests and a custom framework for running them.
Made in 2019.
Tech used: JavaScript
Links: GitHub • Run in browser
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 13 | 290 | 349 | 1232 |
| JavaScript | 13 | 290 | 349 | 1232 |
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.
Tech used: C++, RGBEasy
Links: GitHub
FPS on channel #0: 70
FPS on channel #0: 70
FPS on channel #0: 70
...
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 1 | 38 | 22 | 118 |
| C++ | 1 | 38 | 22 | 118 |
Test your DOS era processor's floating-point performance with this grayscale 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.
Requires a math co-processor.
Made in 2017.
Tech used: C++
| Result (seconds) | 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 |
| 361 | Intel i486DX2 66 |
| 4758 | Intel i386DX 40 |
An early web dev effort of mine, whose goal was to redesign Gona's very useful but somewhat hard-to-read DOS video chip compatibility matrix for improved accessibility. I harvested the HTML matrix data into JSON and implemented a front-end for at-a-glance-friendly access to the data.
Made in 2018.
Tech used: HTML, CSS, JavaScript, C++, PHP
Links: Original matrix
A 16-bit 3D rasterizer benchmark for recreational perf-testing of DOS-based C compilers. Compatible with a variety of legacy C toolchains, such as from Microsoft, Borland, and HI-TECH. The program renders a spinning sphere in VGA mode 13h, then provides characteristics of its runtime performance.
Tech used: C
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 |
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Sum | 19 | 302 | 213 | 1049 |
| C | 10 | 233 | 163 | 916 |
| C/C++ Header | 9 | 69 | 50 | 133 |
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 basic unit tests.
Made in 2019.
Tech used: Java
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).
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Java | 13 | 139 | 139 | 579 |
A learner project in Python by way of a simple ray tracer. Comes with a fairly clean, extendable OOP codebase. Uses PyQt to export the rendering into a PNG image.
Made in 2020.
Tech used: Python, PyQt
Links: GitHub
Exposing film: 100%
Exporting to PNG...
| Language | Files | Blank | Comment | Code |
|---|---|---|---|---|
| Python | 10 | 148 | 51 | 394 |