When I set out to build this blog, I wanted something that felt both modern and timeless. Something that wouldn't look dated in five years, but also wasn't afraid to make bold aesthetic choices.

The intersection of brutalism and cyber aesthetics seemed like the perfect place to start. Clean, monospaced typography combined with strategic hits of neon color creates a visual language that's both technical and artistic.

Design Philosophy

The core principle was simple: let the content breathe. Every design decision should either enhance readability or add intentional visual interest—never both at once.

"Perfection is achieved not when there is nothing more to add, but when there is nothing left to take away."

This meant being ruthless about removing unnecessary elements. No sidebars, no comment sections, no social sharing buttons cluttering the reading experience.

The day-z logo — three overlapping circles in pink, orange, and green
The day-z logo: three neon circles that set the tone for the entire colour palette.

Technical Approach

The technical implementation is deliberately simple:

This approach means the site loads instantly, works without JavaScript, and can be hosted anywhere for basically nothing.

A Taste of Code

Here's an example of the kind of thing you can build with simple tools. A Python script that generates a pulsing neon color value: 

import math
import time

def neon_pulse(base_color, speed=1.0):
    """Generate a pulsing neon glow intensity."""
    colors = {
        "pink": (255, 0, 110),
        "orange": (255, 133, 0),
        "green": (0, 255, 136),
    }
    r, g, b = colors.get(base_color, (255, 255, 255))

    while True:
        t = time.time() * speed
        intensity = (math.sin(t) + 1) / 2  # oscillate 0..1
        glow = tuple(int(c * (0.2 + 0.8 * intensity)) for c in (r, g, b))
        yield f"rgb({glow[0]}, {glow[1]}, {glow[2]})"

# Usage
for color in neon_pulse("pink", speed=2.0):
    print(color)
    time.sleep(0.05)

And for the performance-critical path, the same concept in C: 

#include <stdio.h>
#include <math.h>
#include <unistd.h>

typedef struct {
    unsigned char r, g, b;
} Color;

Color neon_pulse(Color base, double t) {
    double intensity = (sin(t) + 1.0) / 2.0;
    double scale = 0.2 + 0.8 * intensity;

    return (Color){
        .r = (unsigned char)(base.r * scale),
        .g = (unsigned char)(base.g * scale),
        .b = (unsigned char)(base.b * scale),
    };
}

int main(void) {
    Color pink = {255, 0, 110};
    double t = 0.0;

    while (1) {
        Color glow = neon_pulse(pink, t);
        printf("\033[38;2;%d;%d;%dm█ rgb(%d, %d, %d)\033[0m\n",
               glow.r, glow.g, glow.b,
               glow.r, glow.g, glow.b);
        t += 0.1;
        usleep(50000);
    }
    return 0;
}

Color System

The neon color palette serves a specific purpose: to create visual anchors in an otherwise monochromatic space. Here's how I used them:

These colors pop against the deep black background without being overwhelming because they're used sparingly—only where attention is intentionally being directed.

What's Next

This is just the beginning. Future posts will dive deeper into specific technical decisions, design patterns, and experiments with the format itself.

The beauty of a simple, hand-coded site is that it can evolve organically. No major refactoring needed—just edit, save, and publish.