A proof-of-concept project that proposes an end-to-end architecture for a financial machine learning framework. It covers the full lifecycle — from raw market data ingestion and feature engineering to model training, hyperparameter optimization, model serving, and interactive visualization — all orchestrated as reproducible pipelines.

Architecture

The system is composed of five main layers:

Data Ingestion

Raw financial data is loaded into a local DuckDB database using dlt incremental pipelines, orchestrated by Apache Airflow:

Developed a Python script that leverages Stable Diffusion models to enhance video quality by applying stylized post-processing to each frame. Using Gradio and Stable Diffusion 1.5, I discovered that combining diffusion-based rendering with simple shading techniques can significantly improve the visual style of rendered output.

I then integrated frame interpolation into the workflow along with custom color correction to reduce flickering between frames. By automatically generating these intermediate frames, the resulting videos have smoother and more natural motion while maintaining better overall structural consistency.

A project I made while learning GLSL and the graphics pipeline. Given simple rules, automata can produce complex emergent patterns. In this example, I assigned a weight function to each automaton that computes the optimal next position based on the distance to other automata and nearby “fuel” locations. Combined with Voronoi-style noise rules, this creates emergent biological patterns reminiscent of fungi and slime mold structures.

Custom graphics library made in Java for educational purposes. The library supports both perspective and isometric projection and handles all rendering on the CPU, making it lightweight and easy to understand without requiring GPU dependencies. It serves as a hands-on tool for learning the fundamentals of 3D rendering, including projection matrices, rasterization, and coordinate transformations.

Future plans include adding geometry algorithms such as convex hull computation and a basic physics engine.

A minimal implementation of a sigmoid neural network written entirely in C. Because it’s built from scratch with no external dependencies, it can be easily ported to embedded systems, microcontrollers, and other resource-constrained environments.

The library currently supports feedforward inference: given a pre-trained neural network definition (weights and biases), it computes the output. It has been tested against various models trained on the MNIST dataset.

Code can be downloaded HERE

A fully custom graphing calculator built entirely in C, designed to run on low-resolution embedded displays (128×64 pixels). The project includes a custom graphics engine, a mathematical expression parser, and a desktop LCD simulator for development and testing.

Components

Graphics Library

A pixel-based rendering engine built from scratch, featuring:

• Pixel surface abstraction for framebuffer manipulation
• Software renderer with font rendering, UI elements (scroll text, scroll lists, buttons), and texture support
• Scene system with input handling and update loops
• Math primitives — 2D/3D vectors, 3×3 matrices, and rectangles
• Two display backends: SDL2 (graphical window) and ncurses (terminal)

Math Interpreter

A recursive-descent expression parser that evaluates mathematical expressions with: