Natural Motion
Setting a new standard in visuals, CSR 2 delivers hyper-real drag racing to the palms of your hands. Compete against live players across the world with your custom built supercars including LaFerrari, McLaren P1™, Koenigsegg One:1 and many more.
Kuju / Headstrong Games
Pokémon Art Academy is an educational drawing video game developed by Headstrong Games and published by Nintendo for the Nintendo 3DS. It is a spin-off of the Art Academy series featuring characters from the Pokémon media franchise.
Bohemia Interactive Simulations
VBS Tactics allows users to conduct real-time tactical exercises up to the company level. Its intuitive interface can be used to configure doctrine-based orders of battle, plan a mission, execute it in real time, and review the results in after-action review.
Samsung Electronics
The new version of the AR Emoji is released with the Samsung Galaxy S10 range of devices. Samsung's avatars are integrated in the camera app and allow the user to create a virtual presence character that is adopted to their own characteristics.
Personal Project
A real-time WebGL toy that wraps your artwork in a glossy, holographic foil finish: metallic flakes, rainbow iridescence, and a peel-away corner, all rendered live with a custom GLSL shader. Ships as a self-contained tool, plus a Developer/Source tier with the shader source and a commented Three.js integration example.
Personal Project
An experimental offline renderer based on path tracing.
Personal Project
A curses application that picks up bluetooth broadcasts from Govee thermometer / hydrometer devices and displays readings at real-time.
Personal Project
A classic Snake clone for the original Nintendo Game Boy, written entirely in GBZ80 assembly. It runs as a proper Game Boy ROM with tile-based rendering, simple controls, and the familiar constraints of 8-bit handheld hardware.
Personal Project
Epoch is a fast-paced browser clicker with escalating threat mechanics, quick-time events, and a first-person AI narrative that evolves as you grow.
Personal Project
Asciimg is a small utility that allows displaying images in a command line terminal.
A deep dive into rendering the Mandelbulb fractal in WebGL using ray marching, distance estimation, orbit traps, and advanced shading. We explore the math, shader implementation, and how fractals like the Mandelbulb inspire cinematic visuals.
A breakdown of how to build a custom Three.js shader that recreates the iridescent, sparkling look of foil stickers using vertex deformation, angle-based color shifts, and procedural flakes.
This article introduces shadow mapping, a technique for creating shadows in graphics. It explains how to capture depth from the light’s view to find shadowed areas and outlines implementation steps.
Spherical Harmonics are a type of Spherical Radial Basis Function that can be used to encode signals defined on a sphere in a compact way. This makes them an excellent fit for encoding a variety of datasets commonly used in real time graphics.
In Half-Life 2, a directional ambient term is precomputed across the environments and stored in the ambient cube lighting encoding. This post goes over the theory behind the ambient cubes technique and presents an implementation in GLSL.
There are many ways to spread points across the surface of a disk but doing so in an even distribution can be challenging. Vogel’s method solves that problem elegantly. In this blog post, I explore the underlying math and show how to implement it.
Building a Wolfenstein 3D style raycasting engine from scratch in plain JavaScript: grid maps, DDA traversal explained step by step, textured wall projection, billboard sprites, sliding doors, and a weapon HUD.
Number Trail is a Hamiltonian-path puzzle: draw one continuous line that visits every cell exactly once, passing through numbered clues in order. This post goes over the implementation from puzzle file format to board rendering, drag controls, and Warnsdorff's random generator.
The haversine formula computes the great-circle distance between two points on a sphere from their latitude and longitude. It is simple, fast, and accurate enough for many mapping and location tasks.
A reflection on Voyager 1's Pale Blue Dot image, Carl Sagan's moral vision, and why that distant photograph still matters today.
A practical introduction to the Gaia database and its major data releases. Includes a simple ADQL example and a guide to parallax, epochs, and key data fields.
A detailed guide to the ubiquitous Mulberry32 pseudo-random number generator. I go over the theory and include a complete implementation, with deterministic seeding, and practical helper utilities.
A detailed breakdown of the Gray-Scott reaction-diffusion algorithm. Includes an interactive canvas demo and explains the PDE model, Laplacian stencil, double buffering, and boundary handling.
A breakdown of a two-pass shader technique that simulates realistic water ripples from falling raindrops using wave propagation and ray marching to render an interactive puddle with reflections.
A port of a classic Snake game for the Nintendo Game Boy, written in GBZ80 ASM. Covers the state machine, snake ring buffer, occupancy grid collision detection, and VBlank-safe rendering.
A layman's guide to Julian Barbour's timeless view of reality, including Nows, time capsules, Machian dynamics, shape dynamics, and the Janus point, plus how the scientific community responds.
I wrote two small shell scripts that make Seestar ALP + INDI painless on Debian. They create a venv, install deps, apply the pyINDI indi.dtd fix, clone or update upstream, then run a full INDI session.
A practical guide to React useEffect, when to avoid it, common pitfalls, and how cleanup works.
A clean, reliable way to stream a Raspberry Pi Zero 2 CSI camera over RTSP on a headless setup, focusing on a simple configuration that’s easy to maintain. You’ll get the basics needed to bring the stream up and view it remotely with a headless setup.
The classic fire effect, rendered with ASCII characters. Heat values are seeded at the bottom, and then propagated upward through neighbor averaging, and mapped to characters and colors to create animated flames.
A deep dive into rendering animated metaballs (aka blobs) with ray marching, PBR shading, shadows, and CPU driven simulation in WebGL and Three.js.
An exploration of how we approximate an image using an evolutionary strategy. One candidate, one mutation, accept if better. We climb the fitness landscape in real time with frame-budgeted rendering and converge on surprisingly good results.
A practical guide to triple buffering, how it improves smoothness and throughput over double buffering, when to use it, and how to wire it up in modern APIs.
A deep dive into rendering the Mandelbulb fractal in WebGL using ray marching, distance estimation, orbit traps, and advanced shading. We explore the math, shader implementation, and how fractals like the Mandelbulb inspire cinematic visuals.
A breakdown of how to build a custom Three.js shader that recreates the iridescent, sparkling look of foil stickers using vertex deformation, angle-based color shifts, and procedural flakes.
Light stretches as it travels, shifting redward and revealing motion, distance, and even the chemistry of galaxies like record-breaking JADES-GS-z14-0
Polaris, has guided humanity for centuries thanks to its unique position in the night sky. This bright supergiant star serves as a reliable navigation aid, a symbol across cultures, and an intriguing triple star system studied by astronomers.
Unity’s render pipelines, Built-in, URP, HDRP, offer different trade-offs in performance, visuals, and flexibility. Learn how they work, when to use each, and how to extend them with Command Buffers, Render Features, and Custom Passes.
A slow walk on Earth can shift our view of what’s happening right now in a galaxy millions of light-years away. The Andromeda Paradox illustrates how special relativity warps our sense of simultaneity.
A brief report in my latest astrophotography session, where I captured NGC6960, also known as the Veil Nebula.
A quick reference guide to React hooks. When to use useState, useEffect, useRef, useMemo & more. Includes comparison tablew, real examples, and common gotchas to look out for.
Learn how to set up the Seestar S50 smart telescope in Stellarium using accurate sensor and telescope parameters. This guide covers both standard and 2x mosaic modes to help you simulate your field of view for better astrophotography planning.
A practical implementation of the MRS fractal technique, a simple iterative transform built from mirror, rotation, and scale operations.
A step-by-step guide to setting up DOSBox on Linux to play the classic RTS game Z by Bitmap Brothers using your original game ISO.
This short write-up offers a quick overview of a simple method you can use to create a transcript from either a video or an audio file, which may be helpful in a variety of contexts such as documentation, content analysis, or accessibility.
A curated list of technical articles that reverse-engineer and dissect how video games render a single frame, covering geometry, lighting, shadows, post-processing, and more.
Part 1 of a blog post series on full stack development, where I walk through the process of building a simple task management app. This chapter focuses on implementation of the backend services.
I've introduced a feature that lets you listen to my blog's content being read aloud. This post explains how I implemented it using the Speech Synthesis Web API, which requires minimal code and works on most modern browsers.
A step-by-step guide for creating a 'hello world' ROM for the Nintendo Gameboy in assembly
A brief guide on encrypting and decrypting tar archives with gpg
A guide on how to make the ZEXMTE BT-506 dongle work in Debian
A tutorial on using telegram to generate notifications
Notes on using Docker in Debian
A fun experiment in using text to render animated images in a terminal
Notes on a lossy unsigned float number compression technique
This article introduces shadow mapping, a technique for creating shadows in graphics. It explains how to capture depth from the light’s view to find shadowed areas and outlines implementation steps.
A tutorial on interfacing a peripage printer via the command line
A brief guide on using Yubikey as an authentication method with GDM
A brief guide on resolving Intel's PSR issues
A brief post on generating images with Midjourney
Brief notes on building a brachiograph plotter
A brief survey of normal blending techniques
Nanite in UE5 is a virtualized geometry system that renders only visible detail, enabling film-quality assets with millions of polygons and minimal performance cost. It replaces normal maps, supports dynamic LODs, and uses a hybrid rasterizer for optimal efficiency.
A short case study on how to bring old software back to life
A short guide on creating floppy disk images in Linux
Theory and implementation of the De Moivre theorem
Another way to turn your mobile phone into a macro camera
A simple way to turn your mobile phone into a macro camera
The classic demoscene effect explained and implemented in GLSL
Spherical Harmonics are a type of Spherical Radial Basis Function that can be used to encode signals defined on a sphere in a compact way. This makes them an excellent fit for encoding a variety of datasets commonly used in real time graphics.
In Half-Life 2, a directional ambient term is precomputed across the environments and stored in the ambient cube lighting encoding. This post goes over the theory behind the ambient cubes technique and presents an implementation in GLSL.
Generative art is an algorithmic approach to creating unique and dynamic works of art. As technology progresses, it continues to evolve, allowing artists to explore new forms and patterns beyond traditional methods.
A brief explanation on how to render a full screen pass efficiently in OpenGL and DirectX
Wolfram's infamous rule 126 explained in plain terms
The classic demoscene effect explained and implemented in GLSL
A brief survey of various ways OpenGL can draw geometry
An explanation of the math behind half-space testing
An overview of how distributed ray-tracing enhances realism by addressing the limits of traditional ray-tracing, using Monte Carlo sampling to simulate effects like soft shadows, gloss, depth of field, and motion blur.
A listing of CGI films, that played a pivotal role in the history of computer graphics
L-Systems are a mathematical framework for modeling organic structures and fractals. They generate complex patterns and are used in graphics, biology, and procedural generation. In this blog post I share some examples and how to implement them.
A collection of useful interpolation methods, theory and implementation
Lightness constancy allows us to perceive surface brightness as stable despite changes in lighting. The Checker Shadow Illusion highlights how context, shadows, and spatial cues trick the brain into seeing identical shades as different.
A brief guide on using BTRFS
A listing of useful math formulas and their plots
How to generate stereo anaglyphs with ImageMagick
Ray to Plane intersection testing, theory and implementation
There are many ways to spread points across the surface of a disk but doing so in an even distribution can be challenging. Vogel’s method solves that problem elegantly. In this blog post, I explore the underlying math and show how to implement it.
A listing of visibility culling techniques
A simple approach for sprite texture encoding
The Sobel operator explained and implemented in GLSL
NOT SET
A simple method of implementing color grading
The classic plasma effect is a staple of demoscene history. Using sinusoidal functions and color gradients, it creates mesmerizing organic patterns that flow and pulse across the screen.
The physics law of reflection, theory and implementation
Implementation of pixelization effects in GLSL
A high level explanation of FXAA and how to implement it in GLSL
A short guide on NCF specification and how to use it in your own projects
Metaballs, what are they and how to make them
The classic demoscene effect explained and implemented in GLSL
This post shows how the geometric dot product, lengths times cosine of the angle, can be converted into the coordinate form by summing the products of corresponding components, proving both forms are equivalent.
A GPU implementation of Conway's game of life
Theory and GPU implementation of the Mandelbrot and Julia fractal sets
A summary of different approaches for embedding files within c / c++ code
A short guide on enabling and using Primus under Debian Sid
Parallel processing with GNU Make
Sena, D.B.M., Papadopoulos, N. and Gkountis, A., Samsung Electronics Co Ltd, 2019. Method for estimating light for augmented reality and electronic device thereof. U.S. Patent Application 16/409,083.
Mobile devices are continuously becoming more efficient at performing computationally expensive tasks, such as ray tracing. A lot of research effort has been put into using acceleration data structures to minimize the computational cost of ray tracing and optimize the use of GPU resources. However, with the vast majority of research focusing on desktop GPUs, there is a lack of data regarding how such optimizations scale on mobile architectures where there are a different set of challenges and limitations. Our work bridges the gap by providing a performance analysis of not only ray tracing as a whole, but also of different data structures and techniques. We implemented and profiled the performance of multiple acceleration data structures across different instrumentation tools using a set of representative test scenes. Our investigation concludes that a hybrid rendering approach is more suitable for current mobile environments, with greater performance benefits observed when using data structures that focus on reducing memory bandwidth and ALU usage.
Sousa, N.; Sena, D.; Papadopoulos, N. and Pereira, J. (2019). Acceleration Data Structures for Ray Tracing on Mobile Devices. In Proceedings of the 14th International Joint Conference on Computer Vision, Imaging and Computer Graphics Theory and Applications - Volume 1 GRAPP: GRAPP, ISBN 978-989-758-354-4, ISSN 2184-4321, pages 332-339. DOI: 10.5220/0007575403320339
I create art through mathematics and code, driven by a deep appreciation of fractals, science, and the hidden structures of nature. Every artwork is built entirely from scratch using my own rendering engine, sculpted through equations and iteration until the simulation reveals something extraordinary and beautiful. The same recursive logic that carves a coastline, unfurls a fern, or spirals a galaxy finds its way onto the canvas through pure mathematics. No filters, no brushes. Only algorithms, curiosity, and an obsession with the infinite.
A Julia fractal rendered in luminous bronze, where mathematical precision unfolds into a form that feels unmistakably organic. Its swirling contours and intricate textures evoke natural growth, carved wood, flowing tissue, and even the silhouette of a heart. A structure born from equations, yet resonant with the living patterns of nature.
Azure Infinity transforms the Menger sponge fractal into a calm, architectural sculpture of depth, repetition, and infinite structure. Rendered in soft blue tones, the form reveals how mathematics can create beauty through pure logic alone; each opening leading deeper into a pattern that repeats across scale.
Deep navy and icy blue currents sweep across like waves moving under moonlight. Nocturnal Tide captures motion, mystery, and quiet energy, blending oceanic depth with sleek abstract elegance.
