DEV Community: Rodion Shlomo Solomonyk

Developers Need Practical Kubernetes Experience

Rodion Shlomo Solomonyk — Mon, 03 Jun 2024 00:50:06 +0000

In today’s swiftly evolving tech landscape, programmers must constantly stay abreast of the latest technological advancements and methodologies. Mastery in developing and deploying distributed systems is no longer optional; it’s essential. Understanding the entire lifecycle — from development and CI/CD to Kubernetes cluster configuration, deployment, monitoring, and alerting — is critical for any developer aiming to thrive in this environment.

The Importance of Kubernetes in Distributed Systems

Distributed systems, by nature, require robust management of multiple interdependent components across different servers. Kubernetes excels in this environment by automating deployment, scaling, and operations of application containers across clusters of hosts. This makes it an invaluable tool for developers looking to streamline their applications’ operations and ensure reliability and scalability.

The Gap Between DevOps and Developers

Large organizations often have dedicated DevOps teams tasked with fine-tuning Kubernetes environments, which inadvertently might limit direct involvement from developers in these processes. This segregation can create a gap in understanding and hands-on experience for many developers who are otherwise involved in the broader development lifecycle.

The Power of Practical Application

While theoretical knowledge gained from courses and books is invaluable, it pales in comparison to the insights and understanding developed through practical application. This belief drives me to initiate personal projects to explore new technologies and tools actively. For instance, to deepen my Kubernetes knowledge, I developed CicadaKillerWasp.com, a simple interactive quest that leads users through a series of steps culminating in a reward.

Kubernetes: More Than Just Tooling

Understanding Kubernetes involves more than just learning how to use its tools. It requires a deep understanding of the principles behind containerization, orchestration, and microservices architectures. Here are some deeper insights into the components and tools that every Kubernetes practitioner should know:

Containerization with Docker: Before diving into Kubernetes, one must understand containerization with Docker. Containers package up the code and all its dependencies so the application runs quickly and reliably from one computing environment to another.
Microservices Architecture: Kubernetes is particularly effective in a microservices architecture where small, independent services communicate over well-defined APIs. Understanding this architecture is crucial as it affects how applications are developed and deployed within Kubernetes.
Stateful vs Stateless Applications: Kubernetes handles stateless applications — those not saving data to a server or disk — differently from stateful ones, which maintain a continuous state. Learning to manage these different types of applications within Kubernetes is essential for effective orchestration.
Monitoring and Logging: Tools like Prometheus and Grafana are crucial for monitoring the health of applications running on Kubernetes. They provide insights into applications and infrastructure which can be vital for troubleshooting and optimizing performance.
Security Practices: Security within Kubernetes involves more than just managing permissions. It includes securing container images, managing sensitive data through secrets, and protecting traffic with network policies.

Choosing the Right Deployment Environment

For deploying this project, I opted for DigitalOcean over AWS due to its cost-effectiveness and simplicity. Unlike AWS, which often involves complex permissions settings, DigitalOcean offers a straightforward setup process that allowed me to focus more on the project’s specifics without getting bogged down by infrastructural complexities.

Juggling Time: Project and Personal Life

The development of CicadaKillerWasp.com took about two months, fitting around my full-time job. Nights and weekends became my primary working times — thankfully, my supportive wife made this possible.

Deep Dive into Essential Kubernetes Tools and Components

Kubernetes is not only a platform for managing containerized applications but also an ecosystem rich with tools that enhance and simplify various aspects of application and infrastructure management. Here’s an in-depth look at some of the key tools and components essential for anyone working with Kubernetes:

1. Lens and K9s

Lens: Often described as the Kubernetes IDE, Lens provides a comprehensive, user-friendly GUI that allows developers to manage Kubernetes clusters. It integrates with other essential tools like Prometheus for real-time monitoring and has capabilities for viewing logs, managing resources, and accessing a terminal within Kubernetes pods.
K9s: This tool offers a terminal-based UI to interact with your Kubernetes clusters. It focuses on simplicity and productivity, providing a real-time view of cluster activity and resource usage. It is ideal for those who prefer a command-line approach.

2. Helm Charts
Helm is the package manager for Kubernetes. It allows users to define, install, and upgrade even the most complex Kubernetes application. Charts, Helm’s packaging format, provide a set of files that describe a related set of Kubernetes resources. Helm simplifies the deployment and management of applications on Kubernetes and is indispensable for managing releases and rollbacks.

3. Redis
Redis, a powerful in-memory data structure store, is used as a database, cache, and message broker. In Kubernetes, Redis can be used to handle sessions, cache data, and perform real-time analysis. Its performance is critical in distributed systems where quick data access and high availability are required.

4. Prometheus and the Kube-Prometheus Stack
Prometheus is an open-source monitoring system with a dimensional data model, flexible query language, and real-time alerting. The Kube-Prometheus stack leverages Prometheus’s capabilities and adds a collection of resources to provide easy to operate end-to-end Kubernetes cluster monitoring. It includes Grafana dashboards for a rich visualization of the metrics collected.

5. Ingress-Nginx
Ingress-Nginx is an Ingress controller for Kubernetes using NGINX as a reverse proxy and load balancer. It provides an external access point to your services, routing traffic to internal Kubernetes endpoints, and is crucial for managing access to applications running within a cluster.

6. Grafana/Loki Stack
Grafana is an open-source platform for monitoring and observability. It is often paired with Loki, a log aggregation system inspired by Prometheus. Together, they provide capabilities to query, visualize, alert on, and understand your metrics and log data from Kubernetes.

7. Cert-Manager
Cert-Manager is a native Kubernetes certificate management controller. It can help automate certificate management in cloud-native environments, providing a way to acquire certificates from a variety of issuing sources and ensuring certificates are valid and up to date.

8. Messaging Systems (NATS, Kafka, RabbitMQ)

NATS: A lightweight, high-performance messaging system for microservices architectures, ideal for scenarios requiring high speed and scalability.
Kafka: A distributed streaming platform that can handle trillions of events a day. Initially conceived as a messaging queue, Kafka is based on an abstraction of a distributed commit log.
RabbitMQ: Widely used open-source message broker software that supports multiple messaging protocols.

9. GitHub Workflow Actions
GitHub Actions make it easy to automate all your software workflows with CI/CD. Build, test, and deploy your code right from GitHub. They are particularly useful in Kubernetes environments for automating deployment and management tasks directly from a GitHub repository.

10. ConfigMaps and Secrets

ConfigMaps: Allow you to decouple configuration artifacts from image content to keep containerized applications portable. They store non-confidential data in key-value pairs and can be consumed by pods or provide configuration data for system components.
Secrets: Manage the storage and handling of sensitive information, such as passwords, OAuth tokens, and SSH keys. Using Kubernetes secrets is essential for maintaining the security of your applications.

Setting up the entire Kubernetes infrastructure from scratch — defining the deployment pipelines, setting up services, and ensuring proper load balancing and fault tolerance. This practical experience was invaluable, proving that real-world application is the best teacher. The project also incorporated essential Kubernetes tools and practices such as:

Using Cron Jobs for Automation: Automation within Kubernetes, such as scheduling backups or maintenance jobs, can be managed through Cron Jobs, which execute tasks at scheduled times.
Managing Data with Persistent Volumes: Understanding how Kubernetes handles data storage through Persistent Volume Claims (PVCs) is crucial for applications that require data persistence.

These tools and components are fundamental for effectively managing and operating Kubernetes environments. They not only enhance productivity and efficiency but also ensure robust, scalable, and secure application deployments. For developers and DevOps professionals alike, familiarity with these tools will provide a strong foundation in modern cloud-native technology landscapes.

Concluding Thoughts

My experience with CicadaKillerWasp.com reinforced the idea that mastering Kubernetes is not just about handling its complexity but also about leveraging its full potential to build better, more resilient applications. For developers willing to dive deep and embrace the hands-on experience, Kubernetes offers a path to significantly enhance their capabilities and contribute more effectively to their projects and teams. In the realm of software development, where change is the only constant, embracing technologies like Kubernetes is not just an option — it’s a necessity.

c# Debounce and Throttle

Rodion Shlomo Solomonyk — Sun, 02 Jun 2024 18:35:32 +0000

In software development, managing the frequency of function executions is crucial to ensure efficiency, avoid redundant operations, and prevent system overloads. Whether you're working on a distributed system or a local application, implementing debounce and throttle mechanisms can significantly improve performance and reliability. In this article, we introduce two powerful .NET libraries designed for these purposes: DistributedDebounceThrottle and DebounceThrottle.

Links:

DistributedDebounceThrottle: A Distributed Solution

DistributedDebounceThrottle is a .NET library designed to facilitate debounce and throttle mechanisms in distributed system environments. Leveraging Redis for state management and distributed locking, this library ensures that function executions are properly debounced or throttled across multiple instances, preventing excessive or unintended operations.

Key Features

Debounce: Ensures a function is executed only once after a specified interval since the last call, minimizing redundant operations.
Throttle: Limits the execution frequency of a function, ensuring it's not executed more than once within a specified timeframe.
Distributed Locks: Implements the RedLock algorithm for distributed locking to coordinate debounce and throttle logic across distributed systems.
Redis Integration: Utilizes Redis for managing timestamps and locks, offering a scalable solution for state synchronization.

Getting Started

Installation

Install DistributedDebounceThrottle via NuGet:

dotnet add package DistributedDebounceThrottle

Usage

To integrate DistributedDebounceThrottle in your application, ensure you have a Redis instance ready for connection. Here's how to get started:

Configure Services: In your application's startup configuration, register DistributedDebounceThrottle:

public void ConfigureServices(IServiceCollection services)
{
    // Using an existing IConnectionMultiplexer instance:
    services.AddDistributedDebounceThrottle(settings);

    // Or, initiating a new IConnectionMultiplexer with a connection string:
    services.AddDistributedDebounceThrottle(redisConnectionString, settings);
}

Inject and Use IDebounceThrottle: Inject IDebounceThrottle to access debounce and throttle dispatchers:

public class SampleService
{
    private readonly IDispatcher _throttler;

    public SampleService(IDebounceThrottle debounceThrottle)
    {
        _throttler = debounceThrottle.ThrottleDispatcher("uniqueDispatcherId", TimeSpan.FromSeconds(5));
    }

    public Task ExecuteThrottledOperation()
    {
        return _throttler.DispatchAsync(async () =>
        {
            // Operation logic here.
        });
    }
}

Configuration

Customize your debounce and throttle settings via DebounceThrottleSettings:

RedisKeysPrefix: A prefix for all Redis keys (default "debounce-throttle:").
RedLockExpiryTime: The expiry time for the distributed locks (default TimeSpan.FromSeconds(10)).

DebounceThrottle: A Local Solution

For developers who don't need distributed functionalities and are looking for a local solution, DebounceThrottle provides simple yet effective debounce and throttle dispatchers. This library supports asynchronous actions and handles exceptions, ensuring that all Task results from dispatcher calls are consistent with the result of a single invocation.

Debounce Demo

The following example shows how to display entered text after stopping pressing keys for 1000 milliseconds:

class Program
{
    static void Main(string[] args)
    {
        string str = "";
        var debounceDispatcher = new DebounceDispatcher(1000);
        while(true)
        {
            var key = Console.ReadKey(true);

            //trigger when to stop and exit
            if (key.Key == ConsoleKey.Escape) break;

            str += key.KeyChar;

            //every keypress iteration call dispatcher but the Action will be invoked only after stopping pressing and waiting 1000 milliseconds
            debounceDispatcher.Debounce(() =>
            {
                Console.WriteLine($"{str} - {DateTime.UtcNow.ToString("hh:mm:ss.fff")}");
                str = "";
            });
        }
    }
}

Throttle Demo

The following example shows how to call an action every 100 milliseconds but invoke it only once in 1000 milliseconds (after the last invoking completed):

class Program
{
    static void Main(string[] args)
    {
        bool stop = false;
        //trigger when to stop and exit
        Task.Run(() => { Console.ReadKey(true); stop = true; });

        var throttleDispatcher = new ThrottleDispatcher(1000);
        do
        {
            //every iteration call dispatcher but the Action will be invoked only once in 1500 milliseconds (500 action work time + 1000 interval)
            throttleDispatcher.ThrottleAsync(async () =>
            {
                Console.WriteLine($"{ DateTime.UtcNow.ToString("hh:mm:ss.fff") }");
                await Task.Delay(500);
            });

            //iteration every 100 milliseconds
            Thread.Sleep(100);
        }
        while (!stop); //wait trigger to stop and exit
    }
}

Conclusion

Whether you need a distributed solution with Redis integration or a simple local library, both DistributedDebounceThrottle and DebounceThrottle provide robust debounce and throttle mechanisms for .NET applications. By integrating these libraries, you can enhance your application's performance and reliability, effectively managing function executions to prevent system overloads and redundant operations.

Links:

C# Zip Archive Entry

Rodion Shlomo Solomonyk — Fri, 31 May 2024 23:40:38 +0000

Links:

GitHub
NuGet

Introduction

While the .NET ecosystem provides robust libraries for working with ZIP files, developers often encounter limitations due to internal or sealed classes that prevent straightforward extension or modification. In this article, I will discuss why and how I created FastZipEntry, a .NET library designed to efficiently retrieve specific entries from a ZIP archive without extracting the entire archive or iterating through all entries.

The Motivation

Limitations in the Existing Libraries

The existing ZIP handling libraries in .NET, specifically those provided by Microsoft, are powerful but sometimes restrictive. Many of the useful classes and methods are marked as internal or sealed, which means they cannot be extended or modified outside of their original scope. This restriction poses a significant challenge when you need to tweak or extend the functionality to suit specific needs.

Need for Efficient Entry Retrieval

In many scenarios, you might need to access a specific entry in a ZIP archive without extracting the entire archive or loading all entries into memory. This is particularly important for large archives where performance and memory consumption become critical concerns. Unfortunately, the default System.IO.Compression.ZipArchive does not provide a straightforward way to achieve this.

The Solution: FastZipEntry

To overcome these limitations, I decided to create FastZipEntry NuGet , a library that allows efficient retrieval of specific entries from a ZIP archive. This library leverages modified code from Microsoft's System.IO.Compression but extends its functionality to meet the needs outlined above.

Key Features

Efficient Retrieval: Locate and retrieve specific ZIP entries by name without extracting the entire archive.
Decompression: Includes support and access to the Deflate64 algorithm for decompression, also sourced from Microsoft’s codebase.

Implementation Details

Leveraging Microsoft’s Source Code

The core of FastZipEntry is based on the source code from Microsoft's System.IO.Compression library, which is available under the MIT license. Sadly, due to the internal and sealed nature of many classes, I had to copy and modify the necessary code to enable the required functionality. This approach, while not ideal, was necessary to provide the flexibility and performance benefits that FastZipEntry offers.

Adding Deflate64 Support

In addition to the core functionality, I also integrated the Deflate64 algorithm for decompression. This algorithm, taken from Microsoft’s source code, is essential for handling archives that use this specific compression method. By including this in FastZipEntry, I ensured that the library can handle a wider range of ZIP archives.

Usage Example

using System.IO;
using System.Text;
using FastZipEntry;

// Open a ZIP file and create a ZipEntryAccess instance
using FileStream zipFileStream = new FileStream("path/to/your.zip", FileMode.Open, FileAccess.Read);
ZipEntryAccess zipEntryAccess = new ZipEntryAccess(zipFileStream, Encoding.UTF8);

// Retrieve a specific entry from the ZIP file
string entryName = "desired_entry.txt";
ZipEntry? entry = zipEntryAccess.RetrieveZipEntry(entryName, StringComparison.OrdinalIgnoreCase);

if (entry != null)
{
    // Use the entry (e.g., decompress it)
    using Stream entryStream = entry.Open();
    using FileStream outputStream = new FileStream("path/to/extracted/desired_entry.txt", FileMode.Create, FileAccess.Write);
    entryStream.CopyTo(outputStream);
}
else
{
    Console.WriteLine("Entry not found.");
}

Conclusion

I hope FastZipEntry proves useful in your projects, and I welcome any contributions or feedback.

You can find and install the FastZipEntry package from the NuGet repository.
You can also check out the source code in GitHub repository of this project.

Acknowledgments

This library is based on modified code from the Microsoft System.IO.Compression repository, and includes the Deflate64 algorithm from the same source.

c# Message queue with Redis

Rodion Shlomo Solomonyk — Fri, 31 May 2024 23:31:53 +0000

Introduction

In distributed microservice architectures, managing message queue can be particularly challenging when you need to ensure messages are processed in order, reliably, and with the ability to pause and resume processing. The RedisMessagePipeline NuGet package offers a robust solution to these challenges, making your message handling tasks seamless and reliable.

The Problem

Unlike traditional message queue solutions that may be heavy and complicated, RedisMessagePipeline offers a lightweight and straightforward approach. In distributed microservice architectures, managing message pipelines can be particularly challenging when you need to ensure messages are processed in order, reliably, and with the ability to pause and resume processing.

Imagine a scenario where your microservice receives multiple client requests/events/message that need to be processed in the background. Each request might take a significant amount of time to complete, and you need to ensure that:

Messages are processed in the order they are received.
Processing can be paused and resumed without losing data or processing out of order.
Failures are handled gracefully with retries or manual intervention.

Traditional event streaming or message queue solutions like Kafka, Redis Streams, NATS, and RabbitMQ have their strengths but might not provide the required order guarantees and flexible control over the message processing flow.

The Problem with Traditional Event Streaming

When dealing with microservices, maintaining order and reliability in message processing can become complex. Here’s why some popular event streaming solutions might fall short:

Kafka: While it supports ordered processing, Kafka lacks built-in mechanisms for easy stopping and resuming message consumption, making error handling cumbersome.
Redis Streams: Offers powerful features but managing ordered processing across multiple instances requires additional custom logic.
NATS: Known for simplicity and speed, but does not inherently support ordered message processing or pausing/resuming the pipeline.
RabbitMQ: Lacks native support for ordered message processing and mechanisms for stopping and resuming message consumption easily.

RedisMessagePipeline to the Rescue

RedisMessagePipeline is designed to tackle these exact challenges, offering:

Single Message Handling: Ensures each message is processed individually in the correct order.
Failure Handling: Configurable policies for automatic retries or manual intervention.
Pipeline Control: Administrative controls to stop, resume, or clean the pipeline as needed.
Ideal for Long-Running Tasks: Perfect for scenarios where background processing of client requests takes time and order must be maintained.
Simplicity and Efficiency: Unlike traditional message queue solutions that may be heavy and complicated, RedisMessagePipeline offers a lightweight and straightforward approach.

How It Works

Let’s dive into a concrete example to see how RedisMessagePipeline solves these problems.

Step 1: Installation

Install the RedisMessagePipeline package from NuGet:

dotnet add package RedisMessagePipeline

Step 2: Basic Configuration

Set up the Redis client and pipeline settings in your application:

ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost:6379");
IDatabase db = redis.GetDatabase();

var factory = new RedisPipelineFactory(new LoggerFactory(), db);
var consumer = factory.CreateConsumer(new MyMessageHandler(), new RedisPipelineConsumerSettings("client-requests"));
var admin = factory.CreateAdmin(new RedisPipelineAdminSettings("client-requests"));

Step 3: Using the Pipeline

Here’s how to use RedisMessagePipeline to store client requests and process them reliably in the background:

Stop the Pipeline: Temporarily pause message processing, for example, during maintenance or an update.

await admin.StopAsync();

Push Messages: Store incoming client requests in the pipeline. Each message will be processed in the order it was received.

await admin.PushAsync($"any request serialized data");

Resume the Pipeline: Resume processing messages, ensuring they are handled in order.

await admin.ResumeAsync(1, CancellationToken.None);

Process Messages: Start the consumer to process the messages in the background.

await consumer.ExecuteAsync(CancellationToken.None);

Conclusion

The RedisMessagePipeline NuGet package provides a powerful solution for managing ordered and reliable message processing in distributed microservice architectures. It ensures high reliability and consistency, making it an invaluable tool for developers who need precise control over their message pipelines. Unlike some modern event streaming solutions, RedisMessagePipeline offers simplicity and control, making it ideal for scenarios where ordered processing and pipeline control are paramount.

License and Support

RedisMessagePipeline is distributed under the MIT License. For support and contributions.

GitHub repository — https://github.com/coddicat/RedisMessagePipeline

JavaScript 3D ray casting: Chrome is the most efficient browser

Rodion Shlomo Solomonyk — Fri, 31 May 2024 23:16:06 +0000

Introduction

As a full-stack developer, I constantly seek out tasks and projects to keep my skills sharp and my curiosity satisfied. My latest adventure took me back to the 90s, to the world of 3D ray casting. Inspired by classics like Wolfenstein 3D, I set out to implement this technique in pure JavaScript, without relying on the 3D functions of the canvas context. This project turned into a fascinating journey through the intricacies of game development and browser performance.

The Challenge

Ray casting in the style of early 90s games involves casting rays from the player’s perspective, one for each pixel horizontally across the screen. The rays move in intervals of one tile, creating a 3D effect. Despite having no background in game development, I was eager to tackle challenges such as sprite rendering, player movement, and interaction with the environment and moving objects.

Why JavaScript?

I chose to implement the project using pure JavaScript to see if modern browsers and computers could handle the intensive processing required for rendering game scenes. This approach meant manually processing and rendering each pixel, without relying on built-in 3D rendering functions. The question at the heart of the project was: Can modern web technology deliver acceptable performance for such a demanding task?

    const ctx = canvas.getContext('2d', {
      alpha: true,
      willReadFrequently: true
    });

The Journey

What began as a simple curiosity-driven project quickly grew into a full-fledged endeavor, consuming six months of my time. The challenge of optimizing performance was particularly engaging. I frequently revisited my code, eliminating redundant operations and optimizing calculations, especially those involving trigonometric functions. For instance, I used bitwise shifts instead of multiplying or dividing by 2, and bitwise |0 instead of rounding or using Math.floor(), to speed up computations.

Pixel-Level Control

For manipulating pixels, I used Uint32Array, which allowed me to write pixel states directly by index. This approach was effective because three bits represent color, and the fourth bit is alpha, enabling adjustments in pixel brightness and marking screen areas as occupied. This level of control was crucial for achieving the desired visual effects and performance.

const buf = new ArrayBuffer(height * width * 4);
const buf8 = new Uint8ClampedArray(buf);
const data = new Uint32Array(buf);

...

const alphaMask = 0x00ffffff | (light << 24);
const pixel = textureImageData[textureIndex];
data[dataIndex] = pixel & alphaMask;

Overcoming Mathematical Hurdles

One of the most daunting aspects was finding solutions and formulas for rendering horizontal surfaces such as floors, ceilings, and various beams. Without a background in mathematics or game development, this part of the project was particularly time-consuming. However, the result was a visually interesting and acceptable image that met my performance goals.

//// This's just an example. The actual code has been improved to reduce the number of calculations.
public getTileSpriteDataIndexBySideX_positive(
    ray: Ray,
    offset: number,
    textureData: TextureData
  ): number {
    const { width, height } = textureData;
    const fixSinAbs = Math.abs(Math.sin(ray.angle)) / ray.fixDistance;
    const factY = textureData.height * rayAngle.fixSinAbs
    const diff = Math.abs(ray.fixedDistance - ray.distance);
    const fixedCos = Math.cos(ray.angle) / ray.fixDistance;
    const fixedCosDiff = fixedCos * diff;
    const offsetX = offset - fixedCosDiff + (fixedCosDiff | 0) + 1;
    const spriteOffsetX = ((offsetX - (offsetX | 0)) * width) | 0;
    const spriteOffsetY = (diff * factY) | 0;
    const fixedX = height - mod(spriteOffsetY, height) - 1;
    return Math.imul(fixedX, width) + spriteOffsetX;
  }

Not Just JavaScript

Although I initially aimed to use pure JavaScript, I eventually incorporated TypeScript to manage complex code structures more effectively. Additionally, I used the Vue framework to bundle everything together, ensuring a smoother development process and more maintainable codebase.

export type Tile = {
  bottom: number;
  texture?: Texture;
  name?: string;
};

export type Wall = {
  public top: number;
  public bottom: number;
  public texture?: Texture;
  public name?: string;
};

export type MapItem = {
  walls: Wall[];
  tiles: Tile[];  
  mirror?: boolean;
  stopRay: boolean;
}

Performance Insights

The project also served as an insightful browser performance test. On my laptop with an i7–10510U processor, Chrome emerged as the most efficient browser, followed by Edge, Firefox, and Safari. These findings highlighted the varying capabilities of different browsers when handling intensive JavaScript computations.

FPS. 1920x1080. Chrome

FPS. 1920x1080. Edge

FPS. 1920x1080. Firefox

Future Prospects

While the current version of the game is a proof of concept, I have plans to enhance its playability. Future updates may include adding player goals, sound effects, and even multiplayer capabilities. The project has provided a solid foundation for exploring these possibilities.

Conclusion

This journey into 90s 3D ray casting has been both challenging and rewarding. It started as a pet project driven by curiosity and evolved into a deep dive into classic game programming techniques and modern web performance. I invite you to check out the game and explore its source code. Your feedback and contributions are welcome as I continue to refine and expand this project.

Links:

Thank you for reading, and happy coding!