Curiosity,
written in code.

 .----------------------.
 | [o] CPU [||||......] |
 | [o] RAM [|||||||...] |
 |----------------------|
 |     /\      /\       |
 | ___/  \____/  \___   |
 '----------------------'
         [ online ]

The idea

One place to check server health, from resource usage to service status and historical metrics.

How it works

The Go API and React frontend ship as a single executable. An optional collector gathers metrics on Linux. The public demo uses sample data, so you can explore the interface without connecting to a server.

 .----------------------.
 |    EXAM PRACTICE     |
 |                      |
 |  [x] Answer A        |
 |  [ ] Answer B        |
 |  [ ] Answer C        |
 |  progress [|||||..]  |
 '----------------------'

The idea

Built to practice questions before an exam. You can create your own question sets and import them from a JSON file.

How it works

Questions and progress stay in local browser storage. PWA support lets you install the app on your phone. React handles the interface, while MobX manages the learning state.

  CONWAY'S GAME OF LIFE

. O . . .       . . . . .
. . O . .       O . O . .
O O O . .  -->  . O O . .
. . . . .       . O . . .
. . . . .       . . . . .
    n             n + 1

The idea

An implementation of Conway's Game of Life: each generation of cells is determined by the state of their eight neighbors.

How it works

The code separates the simulation engine from the board and settings. A small experiment in how complex patterns emerge from just a few rules.

The simulation contains moving, changing patterns.

 .----------------------.
 | o o o    portfolio   |
 |----------------------|
 | ~ > whoami           |
 | Adam Zielonka        |
 | ~ > projects         |
 | _                    |
 '----------------------'

The idea

A personal space on the web and a playground for experimenting with a terminal interface.

How it works

The interface uses native DOM APIs, with commands defined in Markdown. Since its first version in 2017, the site has moved through React and Svelte before returning to plain TypeScript.

   _________ _________
  / React  /|  MobX  /|
 /________/ |_______/ |
 | <App/> | | store | |
 |        | /       | /
 |________|/|_______|/

     LEARN + BUILD

The idea

Teaching materials created to share practical frontend development with teammates and students, based on building interfaces for factory applications.

How it works

The tutorial focuses on React components and MobX state management. It puts these tools in the context of applications used on computers, tablets and scanners, with REST services connecting the frontend to SAP systems.

 .----------------------.
 |   UNIT CONVERTER     |
 |                      |
 |   1 m  ->  100 cm    |
 |                      |
 |   [7] [8] [9] [+]    |
 |   [4] [5] [6] [=]    |
 '----------------------'

The idea

A unit converter whose conversion sets can be extended instead of being fixed in the application. Create your own measures with the built-in editor or define them in a JSON file.

How it works

Conversion definitions describe unit symbols, localized names, prefixes, factors and offsets. This keeps the conversion data separate from the Android interface. A ready-to-install APK is available in GitHub Releases.

 .--------------------.
 |    /\         .    |
 |   /  \   /\        |
 |  /____\ /__\       |
 '--------------------'
       /      \     //
      /        \   //
                   \/

The idea

A drawing application created to explore cross-platform desktop programming: a canvas, drawing tools and color controls built with C++ and Qt.

How it works

Qt provides the interface and drawing APIs. The app saves drawings as images, and its release workflow packages the same code for Linux, Windows and macOS with the required Qt libraries included.

       [ .PAS ]
           |
 .----------------------.
 |  Docker + DOSBox     |
 |    Turbo Pascal      |
 '----------------------'
           |
   .EXE -> [ browser ]

The idea

Keep old Pascal programs playable with a repeatable build process. This is the tool behind the browser versions of Deska and Saper, two games I first wrote in high school.

How it works

A Docker image converts UTF-8 source to CP852 and runs Turbo Pascal inside DOSBox. It then generates a website that runs the compiled DOS executable through js-dos. Use it locally with an optional watch mode, with Docker Compose or in GitHub and GitLab CI pipelines.

       [ DECISION ]
          /   \
    [cost]   [quality]
       \       /
        [ AHP ]
           |
     1. A  [|||||||]
     2. B  [||||   ]

The idea

Make a decision with several competing criteria by breaking it into explicit weights and alternatives. The application explores the Analytic Hierarchy Process through an editable desktop interface.

How it works

Define criteria, adjust their importance and enter values for each alternative. The application generates comparison matrices, calculates priorities and combines them into an overall ranking. Separate views expose the input data, matrices and results so you can follow the calculation.

.----------. .----------.
| PLAN     | | TRANSFER |
|    12    | |    08    |
'----------' '----------'
.----------. .----------.
| PICK     | | POST     |
|    05    | |    03    |
'----------' '----------'

The idea

Explore how a compact tile interface can make warehouse work easier to scan, from planning and transfers to picking and posting.

How it works

React renders the tiles while MobX manages their state. Counters, progress indicators and colors distinguish workflow stages; filters and highlighting help inspect them. The project is an interface demo with sample data.

     [ action: +1 ]
            |
            v
    .---------------.
    |   count = 1   |
    '---------------'
            |
       [ view: 1 ]

The idea

A small, focused example of reactive application state. A counter makes it easy to see how a change travels from a user action through a store to the interface.

How it works

An observable counter is updated by an action, while a computed value derives its double. React observer components update when the values they use change, keeping the example small enough to read alongside its unit tests.

 .----------------------.
 |  <Counter />   [+]   |
 |  <Counter />   [+]   |
 |                      |
 |       SUM = 2        |
 |                      |
 |   <App /> -> update  |
 '----------------------'

The idea

Explore reusable components and shared reactive state with a collection of counters. Add up to four counters, edit their values and watch the total change.

How it works

A writable store holds the counter values. Derived stores calculate the sum and whether another counter can be added, so the interface reacts to updates without manually synchronizing each component.

 .----------------------.
 | [] [] [] [] [] [] [] |
 | [] [] [] [] [] [] [] |
 |             .        |
 |           o          |
 |                      |
 |        ======        |
 '----------------------'

The idea

One of my first games, written in high school in January 2011. Move the paddle, keep the ball in play and clear the bricks in a Breakout-style arcade game.

How it works

The original program lived in one large loop before a rewrite in 2020. DOS Pascal Docker now handles character encoding and compilation with Turbo Pascal, while js-dos runs the DOS executable in a browser.

  +---+---+---+---+
  | 1 | 1 | 1 |   |
  +---+---+---+---+
  | 1 | * | 2 | 1 |
  +---+---+---+---+
  | 1 | 2 | * | 1 |
  +---+---+---+---+
       MINESWEEPER

The idea

A high-school project from May 2011 inspired by Windows Minesweeper. Use the numbered clues to uncover safe cells and avoid the hidden mines.

How it works

The game keeps its original DOS implementation, including its menu, help and end-of-game screens. DOS Pascal Docker builds the Pascal source, and js-dos makes the resulting executable playable without installing a DOS environment.

   |      []        |
   |    [][][]      |
   |                |
   |                |
   |[][]    []      |
   |[][][][][][][]  |
   +----------------+
         TETRIS

The idea

A desktop Tetris implementation created in June 2015 for a university course in computer graphics and visualization. Arrange falling blocks and clear completed rows.

How it works

Written in C++ with OpenGL and GLUT, the project brings together game logic, rendering and keyboard interaction. It includes menu, settings, help and results screens alongside the game board.

          |>
       ___|____
   ___/  [] [] \___
  /________________\
 ~~~ ~~~ ~~~ ~~~ ~~~
      A  B  C  D
   1  .  X  .  .
   2  .  X  .  O

The idea

A browser version of Battleship: find the opposing fleet on a coordinate grid before the computer sinks yours.

How it works

The board and turn logic live separately from the interface. The computer starts with random shots, then explores neighboring cells after a hit and follows the ship's direction once more of it is revealed. Hits keep the turn going; a miss passes it to the opponent.

 .------.
 | A    |------.
 |  /\  | K    |------.
 |  \/  |  <>  | Q    |
 |    A |      |  ()  |
 '------|    K |      |
        '------|    Q |
               '------'

The idea

Bring the Polish card game Pan to a shared virtual table for two to four players. Play against computer opponents or watch them compete, with a responsive interface and a history of moves. Players try to empty their hands; the last player holding cards loses.

How it works

Opponents range from random and greedy strategies to tactical evaluation, flat Monte Carlo simulation, MCTS with UCT and MaxN search. Monte Carlo bots sample unknown hands; the experimental MaxN opponent deliberately sees every hand. Simulations run separately from the live game with bounded search, and repeated-state memory helps some bots reduce loops. These are experiments with different decision strategies, with no verified ranking of playing strength.

 [o o] . . . [x x]
 [o o] . + . [x x]
   . . . . . . .
 . . . [>] . . . .
   . . . . . . .
 [* *] . + . [# #]
 [* *] . . . [# #]
       [:::] 6

The idea

A browser version of Chińczyk, also known as Ludo, for two to four players sharing one screen. Choose people or computer opponents for each color, race your pieces home or watch an all-bot match.

How it works

The interface highlights legal moves after each die roll and lets you pause play or adjust the opponents' speed. Bots use different strategies: releasing pieces, racing one pawn, avoiding danger, seeking captures or exploring possible continuations. On phones, the die and controls stay at the bottom of the screen for easy access.