j3x.dev

A project of server and controller designed for SmartHome applications focused on managing heating installations. The system's goal is simple – to enable real-time monitoring of the installation, provide historical measurement data, and (in the near future) allow adjustments.

This system was developed due to family needs. It required support for "Chinese" non-standard sensors and reverse engineering their registers. For this project, I wrote communication code for temperature sensors using CH341 MODBUS RTU. A user interface was created to provide continuous monitoring of the installation, which consists of several sensors. Everything is displayed on a clear installation diagram similar to SCADA systems.

I strive to make the implementation as configurable as possible. The source code includes a configuration file describing the sensor map, installation diagram, and other additional parameters. The project is distributed under open-source principles – I want to allow others with similar needs to use my work for their own purposes.

Currently, the system is still in the early stages of development, though it is already being used successfully.

In early 2023, together with @michalbortkiewicz, we decided to delve deeper into the increasingly popular topic of large language models and their practical applications.

We created a prototype of an intelligent conversational toy that met the requirements of an artificial assistant. The toy could recognize speech, infer, formulate responses to questions, and produce speech. In various settings, it could also tell stories and even solve problems. The prototype was based on a Raspberry Pi 4 powered by a battery and connected to the internet. The software managing the conversation was written in Python. We performed text transcription (Speech-To-Text) and speech synthesis (Text-To-Speech) on the device using local open-source models (Faster Whisper and Tacotron 2). Inference and response generation were handled by external models (OpenAI GPT-3.5) with dedicated prompt engineering. The entire setup was embedded inside a plush teddy bear.

The biggest challenge was dealing with delays. Each AI model introduced additional latency, ranging from several hundred milliseconds to a few seconds. To maintain smooth conversation flow in the early stages of prototype development, we used scripted filler phrases. Multithreading allowed us to bridge the gaps between user input and toy responses.

The main goal was to create a generic solution that could facilitate the development of entire series of interactive toys. We experimented with educational toys which teach languages (like the one shown in the attached video) or colors and also with toys with purely entertaining aspects. One such example was the interactive Yoda Master, which presented a unique challenge due to its distinct voice and grammar. We managed to train a Text-To-Speech model and craft appropriate input data for a large language model. This resulted in a prototype toy for Star Wars fans, which narrated the universe in the voice and style of the Master.

The project then transitioned from the prototype phase to the MVP phase, where we aimed to create a more practical solution — incorporating most computations in the cloud and a horizontally scalable architecture. However, the work was halted due to the market's insufficient maturity for the idea we presented.

The Archive of Diploma Theses (APD) is one of many web services integrated with the University Study-Oriented System (USOS – a comprehensive system used by most Polish universities and several in Europe). This application serves as a catalog and repository for electronic versions of academic papers produced at the university.

The global situation in 2020 increased the importance of computer systems. Many processes previously handled in traditional ways had to be rapidly transitioned into the digital world. Specifically, student service processes could no longer continue in their existing form. It was necessary to introduce alternative processes or adapt existing ones to the new circumstances.

While working in the Zespół Roboczy ds. USOS, I developed a tool that extends the basic functionality of the application by supporting processes for announcing, negotiating, and approving diploma thesis topics. I introduced a solution that allowed for the elimination of paper documents and standardized procedures across universities. The new interface also assisted all students facing the task of choosing a thesis topic by offering a comprehensive catalog of proposed topics.

The new module enabled the complete transition of the paperwork into digital, structured procedures. It significantly accelerated communication between students, supervisors, and examination committee members. Since then, it has been successfully used at many universities in Poland and Europe.

The project is described in my master's thesis, which you can read here (mostly in Polish). The module was deployed in production at the university before I defended my thesis. All the formalities related to my exam were handled using... the very module I developed.

An updated version of the website for Ogrodnictwo i Szkółka Roślin Łangowscy. Due to the success of the previous online version, the owners decided to invest in a more modern website. The impact of the online brand was significant, and the site became the primary promotional tool for the company.

The website (like its predecessor) was built with ease of configuration in mind. The owners have substantial freedom in managing the content. The interface allows for adding news, editing the offerings, updating business hours, and managing all other information.

The design of the site meets more modern standards and moves away from outdated "container" styles. Sections are adapted to wide screens and fill a larger portion of the window. The site is interactive, featuring animations and moving elements, making it more visually engaging. This version was also implemented in a responsive web design (RWD) style, ensuring compatibility with mobile devices and other non-standard resolutions.

Responsibilities: graphic design, implementation in WordPress, security, hosting, SEO, online branding

TwojeWnętrza approached me to help create business value online. My task was to develop a complete e-commerce store along with a company website. The store needed to allow users to browse the company's offerings, register and maintain their accounts, and make purchases (from product browsing to payment).

At the time, this was quite a challenge but was successfully completed. I managed to design, implement in WooCommerce, and launch a fully operational portal. A significant portion of the work was dedicated to security and SEO optimization. The store received a modern design and a mobile-friendly version.

At VersaBox, one of my tasks was to create a cross-platform application for remote configuration of robot electronic modules. Robots and other IoT devices often consist of complex control and measurement systems that require proper parameter settings for correct operation. Adjusting values and configuring systems is a tedious task that often requires halting the entire device and making a wired connection with a dedicated programmer.

To address this, I developed the VBarWeb web application. The application server, installed on an onboard computer (or any other microcomputer controlling the device), acts as an intermediary between the user and the network of connected electronic modules. The application allows not only for quick, remote viewing of real-time sensor readings from the robot but also for configuring advanced equipment (e.g., changing the PID settings of motor controllers).

Communication with the user is conducted over WiFi. Communication between the server and electronic modules occurs via the CAN bus, using a specially designed protocol. The application enables communication with any equipment that meets the communication requirements. The structure of its readings and settings is loaded using an XML file. The application also allows for the automation of repetitive tasks, such as setting default configurations across a series of robots.

A full description of the project is included in my engineering thesis, which can be read here (mostly in Polish).

The initial version of the website for Ogrodnictwo i Szkółka Roślin Łangowscy. The site became a key promotional tool for the nursery, attracting new customers and facilitating the management of their offerings. Thanks to an intuitive interface, the owners could independently update the content.

The website was built with ease of configuration in mind. The site owners had significant flexibility in managing the content. The interface allowed for adding news, editing the offerings, updating business hours, and managing all other information.

In addition to executing the project and implementing the site using WordPress, I successfully established the company's online presence. Together with the owners, we developed the company’s online image and optimized the site for search engines. As a result, the company achieved a top position in local search results related to gardening.

After a few years, the website received a refreshed look, and the version shown in the screenshot was retired.

Design and development of a functional website for the Robotics Student Association (KNR) at the Warsaw University of Technology, Faculty of Mechanical Engineering and Aeronautics (MEiL). The website aimed to promote the association's activities, facilitate new member recruitment, archive projects and events, and enhance user interaction.

As a member from 2016-2017 and the creator of the site, I was able to leverage my skills to support the association's activities and promote a passion for robotics.

The site was built using WordPress and was designed from scratch by me.

Between 2013 and 2015, I completed a series of projects in collaboration with Scorise.

I was involved in tasks such as cutting complex designs (i.e., converting graphic designs into websites), configuring WordPress sites, adapting graphic themes, and optimizing website security.

The attached image shows an example of a website I sliced for the company KMZOZ.pl.

While collaborating with the Talent Association, I designed preparatory problem sets for the Junior Olympiad in Informatics (OIG).

The problems consisted of creatively masked algorithmic problems using colorful stories. The task solver had to analyze the story and formulate a mathematical problem. Using the example queries and answers provided in the problem, the solver was then required to propose a computer program that, while meeting the specified conditions (such as maximum number values and memory-time constraints), would solve the problem for a set of test cases. A particular challenge in the proposed problems was to find a solution with appropriately low computational complexity.

I prepared four sets of problems along with sample solutions that address these problems. The problem statements (in Polish) and the code (written in C++) can be accessed through the links below:

• Napoleon's Army: problem statement, solution.
• Biological Bomb: problem statement, solution.
• Energy Loss: problem statement, solution.
• Voltage Drop: problem statement, solution.

One of my first commercial projects.

A website for a local company that manufactures garden furniture. Despite its age, it is still available online.

My responsibilities included: design, slicing, hosting, and populating the site with content.

The website was built using pure HTML and CSS.

A passion project that kept me engaged for 3 years.

RAG3 is a 2D top-down shooter built on top of my own custom, cross-platform engine. The gameplay revolves around skillfully progressing through levels while eliminating all encountered obstacles. The game is characterized by its dynamic pace, often requiring a high level of concentration.

One of the most distinguishing mechanics is active time manipulation. Players can slow down the gameplay for short periods (bullet time) or even travel back in time. This feature is tightly integrated with the gameplay and can be used dynamically. The time manipulation mechanics is also deeply connected to the storyline, which can only be uncovered through gameplay.

The goal of the game is to deliver excitement and joy through combat with various creatures while exploring a wide range of locations (from labyrinths to open worlds). Warning! Time travel can be very dangerous and may have disastrous consequences. Be careful when encountering your past self!

In addition to the single-player campaign, the demo version also includes a multiplayer mode. The current package supports multiplayer in a classic deathmatch format, staying true to the retro game style.

The game features an original soundtrack composed by me and custom graphics. Alongside the game's development, I worked on creating a cross-platform engine using C++, SFML, GLSL, and TGUI. Over the course of 3 years, I developed a comprehensive solution for creating various types of games. The systems included in the RAG3 engine are:
- Shader-based graphics engine
- Physics engine
- Sound/music engine
- Configuration file system using a simple interpreted language (*.j3x)
- Network communication via custom protocol based on UDP and TCP
- Event engine (for time manipulation)
- Artificial Intelligence engine, featuring efficient pathfinding and decision-making
- Complex user interface
- RPG system (weapon upgrades, experience points, character improvements)
- NPC dialogue system
- Particle systems (animations, explosions)
- Achievement and stats system
- Save/load system
- Full editor for editing maps, scripted behaviors, game parameters, and objects

Useful links:
- https://j3x.dev/rag3 - RAG3 website
- https://jul3x.itch.io/rag3 - demo download link
- https://github.com/jul3x/RAG3 - game code

An implementation of the popular cellular automaton "Conway's Game of Life" written in x86_64 Assembly (NASM syntax).

How does it work? A grid of live or dead cells with dimensions n x m. The game proceeds iteratively. In each new iteration, every cell changes its state or remains the same.

- If a cell is dead and has exactly three live neighbors, it comes to life.
- If a cell is alive and has two or three live neighbors, it stays alive.
- Otherwise, it dies.

These three simple rules allow for the construction of very advanced and interesting patterns, which have been the subject of many studies worldwide over the years. "The Game of Life" is Turing complete (in simple terms: it can solve the same set of problems as a computer). For example, this allows for building a computer with a monitor or playing the Game of Life within the Game of Life.

A simple, configurable 3D music visualizer written in pure C++ and OpenGL, using a sound analysis library.

The animation displays a special grid of points (rendered in a user-defined way) in 3D space based on the current sound spectrum. For sound analysis, the program primarily uses the Fast Fourier Transform (FFT) and energy analysis in one-second windows. It then presents a logarithmic graph of the intensity of each frequency range using the height of the points on the grid. On the second axis, the height of the points is extrapolated using a normal distribution to smooth it out and create a "hill" effect.

Additionally, camera movement depends on the current sound energy. The higher the value, the faster the rotation. The higher the bass frequencies, the closer the zoom to the grid of points.

All these features come together to create a pretty neat effect, which works best with energetic tracks. The visualizer with minor post-processing can be seen in the attached video.

The Turing machine is an abstract model capable of executing algorithms, and despite its simplicity, it can realize any program that a modern computer can run. Introduced in 1936, it has since become a crucial subject in logical theories and complexity proofs in computer science.

The structure of a standard Turing Machine consists of an infinite tape divided into cells and a head that moves along the tape. Each cell can hold a certain value from a selected set of symbols, and the head can occupy a position on a cell and be in a specific state from a chosen set of states. The execution of any algorithm on a Turing Machine involves reading the value of the cell by the head, writing a new value, changing the state from the current one to the next, and moving left/right or halting the computation. Decisions regarding new values, states, and movements are made based on the rules outlined in the algorithm.

A Turing Machine where there is only one possible behavior for a given cell value and state is called deterministic. If there are multiple possibilities, such a machine is a non-deterministic Turing machine and takes on more of the character of a thought process rather than an actual machine that can be built.

In this project, I presented a non-deterministic Turing Machine interpreter written in Python. Specifically, my solution allows for checking whether the input machine will return a positive result for a given tape within a limited time (a restricted number of iterations). I wrote a few tests to check correctness, such as a Turing Machine that verifies if a word on the tape is a palindrome and another that checks if the first number on the tape is the square of the second. I also added a script that translates multi-tape Turing Machines into a single tape.

Abstract, yet interesting.

The satisfiability problem (SAT) is one of the most important problems in mathematical logic. It involves determining whether there exists any assignment of truth values (either "true" or "false") to a given logical formula (a representation of logical variables and operations among them) such that the formula evaluates to true.

While the formulation of this problem may sound entirely theoretical and abstract, it carries a number of more tangible consequences. This problem belongs to the class of NP problems, meaning (in a simplified sense) that finding a solution for a given logical formula is computationally intensive, whereas verifying whether a solution is correct can be done in a shorter (polynomial) time. Problems in this class are often characterized by a brute-force approach, which entails exploring the entire space of possible solutions and checking which one is correct.

The SAT problem is also NP-hard (being in the NP class makes it NP-complete). This means that all problems that belong to the NP class can be transformed (in polynomial time) into the SAT problem. This makes it a completely universal problem, as finding an optimal solution for SAT implies finding optimal solutions for every problem in the NP class. This issue is one of the current Millennium Prize Problems (more here).

The computational complexity of the SAT problem greatly limits the ability to optimally find solutions. However, there are various optimization techniques that allow for the resolution of a considerable number of logical formulas in a reasonable time. In a project completed during my master's studies, I presented a solution to the SAT problem using the DPLL algorithm, depth-first search, and the divide-and-conquer principle. The implementation was written in Haskell.

Counting how many points in a given set (2D or 3D) have all coordinates greater than the given ones is a very simple problem. The challenge begins when there are so many points that the entire set cannot fit into the RAM of a single computer. The challenge becomes even greater when the set cannot fit onto the disks of a single computer. Another complication is the number of query points (points that are used as comparison criteria), which can be comparable to the number of all points in the set.

To solve such problems, parallel algorithms are necessary, allowing computations to be performed simultaneously on many machines. The challenge in designing such algorithms is ensuring proper access to memory, i.e., subsets of data. The most optimal algorithms should transfer the smallest possible amount of data between computing units to minimize the speed losses caused by communication delays. Parallel algorithms whose access to data is theoretically the most optimal are called minimal.

In the linked repository, I have presented a solution to the problem from the first paragraph for two cases (2D and 3D) using a minimal algorithm described in the publication: https://dl.acm.org/doi/pdf/10.1145/3070607.3075961. The problem was solved in Scala using Apache Spark as a framework for MapReduce and YARN and HDFS as the distributed file system for data storage.

The project also includes scripts for setting up a computing cluster, data generators, and sequential checkers to test the performance of the distributed algorithm on small datasets. The project was created during a Big Data Processing course at MIMUW.

A simple compiler for the Latte programming language (a statically typed language with object-oriented features) to x86 GAS assembly. The language is syntactically and semantically similar to Java. A description of its context-free grammar can be found in the GitHub repository.

Along with the language syntax, the compiler is a fully functional development tool that allows the writing of complex programs. The repository contains dozens of test programs and automatic functional tests (including output comparison).

The project was developed during my master's studies.

As an introduction to the world of compilers, I also implemented a simple compiler for arithmetic expressions to JVM bytecode and LLVM bitcode. You can see the code here.

A PC game controller based on an STM32 microcontroller with an ARM Cortex-M core (the code was implemented on the STM32F411xE module). It uses standard buttons (shoot / jump) and an inertial measurement unit (IMU - accelerometer + gyroscope) for player control. The main feature of the controller is enabling dynamic gameplay through air movements.

The device communicates with the computer via USART USB, transmitting real-time sensor readings connected to the microcontroller. The microcontroller code implementation utilizes interrupt-driven operations to optimize resource use. Internal communication between the microcontroller and sensors takes place using the I2C protocol.

I also wrote code for a simple driver that supports the controller connected to a PC, allowing you to play the classic game Wolfenstein 3D. You can see it here.

Gravity is an interactive simulator of interplanetary gravitational forces. It allows for the simple creation of space motion scenarios, the active addition of new objects, and saving examples for later. It consists of a simple graphical interface and mouse + keyboard controls. A configuration file is also available to the user, allowing changes to the appearance and basic physical constants considered in the calculations.

The operation is based on solving systems of motion equations (differential equations) in real-time using the 4th-order Runge-Kutta algorithm. Given the masses and positions of the objects relative to each other, the algorithm in the simulator can calculate, with sufficiently good approximation, the system of forces acting on each object individually. Using Newton's laws of motion, such systems can be transformed into systems of motion equations, which can then be solved numerically for given initial conditions.

An additional feature is the handling of object collisions. Gravity handles such events using the "bigger wins" method and applies the law of conservation of momentum to calculate the further trajectory of the remaining object.

The project was implemented in C++, SFML, and TGUI as an introduction to creating my own framework/engine for developing 2D games. I started working on the graphical and physics modules, as well as a simple configuration file handler in a custom format (*.j3x).

Many algorithms designed for problem-solving by computers draw inspiration from nature. One such group is evolutionary algorithms, which find optimal solutions through evolution and iteratively refining proposals until the one best suited to the given conditions is found. During my studies, together with @danielm1405, we implemented a specific case of an evolutionary algorithm—a genetic algorithm. We demonstrated its application for... finding the optimal design of an off-road vehicle.

The genetic algorithm is a variation of an evolutionary algorithm that, in simplified terms, involves: - Creating a population (in our case, vehicles) of random units. - Evaluating which of them performed best at the task. In our case, it was to travel the greatest distance on a given 2D map composed of hills, holes, and steep inclines. - Selecting a certain percentage of the winning units. We chose the top 5-10% of designs. - Creating the next population based on two mechanisms—crossover and mutation. The first process involved creating a new unit based on two randomly selected "parents." The "child" had averaged (but partially biased towards one or the other parent) parameters of the parents. Mutations involved introducing completely new values (mutations) for random parameters in a small part of the new population. Both processes were equally important to find the optimal solution to the problem. - Repeating the process hundreds to thousands of times until the resulting solution seemed optimal.

Due to the random nature of evolutionary algorithms, the solutions proposed can often be surprising. Different runs of the program can yield completely different results. However, at some point in each run, after several hundred generations (iterations of the population), a stabilization trend becomes noticeable. The process of reaching the final solution is also quite fascinating.

Our implementation allows users to create their own maps and control the parameters of the genetic algorithm. A visualization of the progress of each population and how each unit individually performs the task is also displayed.

In the era of ubiquitous hoverboards, a robot whose sole task is to maintain balance on a single axis of wheels might not seem impressive (actually, it was unlikely to spot any hoverboard in Poland in 2018). However, it presents a very interesting theoretical and engineering challenge that can be quite troublesome.

Implementing such a project requires complex theoretical calculations using differential equations of motion. These equations must then be converted into state variable equations and solved using control theory for a given equilibrium point. The solution allows us to simulate the robot's behavior under various control methods.

The simulation enables optimal selection of the relationship between the robot's tilt and the force applied by the motors. This relationship must then be implemented in the robot's controller. Selecting the appropriate electronic components is crucial: microcontroller, accelerometers, motor drivers, battery, and the motors themselves. All elements must work together and be controlled by software uploaded to the microcontroller (handling sensor readings, calculating required power, transforming values into signals for the motors).

Since the robot is a physical entity, designing its structure and selecting the appropriate mechanical components is also necessary, followed by assembling everything into a whole. Ultimately, this often leads to the realization that the results from theoretical calculations do not align with reality (mainly due to accumulated simplification errors), necessitating experimental "tuning" of the control algorithm.

The project was a fascinating adventure and allowed for a more practical entry into the field of robotics. I described the theoretical foundations of the project here.

Spirit Runner is a dynamic action platformer focused on skillfully navigating levels while escaping danger and collecting as many points as possible. The game takes place in a two-dimensional side-scrolling format. Players can choose between two game modes: standard mode, which involves progressing through levels with increasing difficulty, and endless mode, set on a procedurally generated map. The game was developed in collaboration with @danielm1405.

Player control is limited; the only action available is choosing when to jump. Players have no influence over the game's speed. The character runs continuously throughout the game, and the player's task is to ensure they do not fall into pits, jump from building to building, grab onto steel pipes, and avoid fires (and other obstacles). This simple mechanic has many implications, as the maps are designed to offer players a choice of multiple paths. However, not every path is the right one—some may be more challenging than others.

The game also features a replay mechanism. After successfully completing a level, players can relive their experience through a recorded replay from a special "camera."

This is one of the few projects I've written in Java. In hindsight, I know it will definitely be the last one in that language ;).