Project 1: Build a Console-Based Calculator Learn to think through a problem systematically and develop a well-organized program to solve it. Utilize core Kotlin language features such as conditionals and functions to design an interactive calculator and practice validating user input.
Project 2: Build a Versatile Task Manager Design and implement a console-based task manager application that enables users to add and delete tasks, display the task list, update task statuses, and more. Structure the app and its data using lists, classes, and data classes and incorporate robust error handling as well.
Project 3: Build “Hello, World!” in JavaFX Discover the classes and layout containers that form the fundamental building blocks of any JavaFX visualization. This project serves as a basic template for subsequent projects requiring more elaborate visualization schemes.
Project 4: Visualize Data as a Bar Chart Learn about the core charting tools of JavaFX by creating a bar chart using the monthly sales data from a fictitious company. Plot text data on one axis and numeric data on the other.
Project 5: Create a Multiseries Line Chart Visualize multiple datasets at once by developing a line chart that compares the average heights of men and women of different ages. Plot numeric data to both the x- and y-axes.
Project 6: Draw a Spiral Seashell Use Kotlin’s built-in trigonometric functions along with the JavaFX canvas to draw a spiral seashell. This is the first of many projects where you’ll leverage the powerful free-form drawing features of JavaFX to create a complex two-dimensional image.
Project 7: Animate a Square Define the start and end state of a solid red square and let JavaFX transitions do their magic by smoothly moving the square back and forth inside the graphics window.
Project 8: Animate a Bouncing Ball Harness JavaFX’s powerful timeline and keyframe features and manipulate object properties to create captivating motion. Animate a ball gracefully gliding inside a rectangular box.
Project 9: Find the Square Root with the Babylonian Algorithm  Develop a simple app that converges on the square root of any positive number by iteratively refining an approximation of its value. Try to figure out what technique Kotlin’s built-in square root function employs to do the same.
Project 10: Create Pythagorean Triples with Euclid’s Formula  Implement Euclid’s method for generating Pythagorean triples (sets of integers where the sum of the squares of the first two numbers equals the square of the third number).
Project 11: Identify Prime Numbers with the Sieve of Eratosthenes  Take a peek into the world of prime numbers and utilize an ingenious method developed by Eratosthenes to reveal them up to a given integer.
Project 12: Calculate Earth’s Circumference the Ancient Way Time travel back to ancient Egypt to re-create an experiment that uses simple trigonometry to estimate Earth’s circumference and radius with remarkable accuracy.
Project 13: Code the Fibonacci Sequence Generate a list of Fibonacci numbers from scratch and then draw the Fibonacci spiral. Use advanced JavaFX features to explore how these concepts are embedded in both natural and man-made systems.
Project 14: Find the Shortest Distance Between Two Locations on Earth Utilize the haversine formula and an understanding of latitude and longitude to calculate the shortest distance between any two locations on Earth’s surface while accounting for Earth’s spherical shape.
Project 15: Do Encryption with the Hill Cipher Implement a classic encryption algorithm that’s based on the linear transformations of texts. Convert plaintext into ciphertext and vice versa using vectors, matrices, and modular arithmetic while employing multidimensional array operations.
Project 16: Simulate a One-Dimensional Random Walk Learn to simulate random processes by investigating how far an entity will travel after taking n random steps. Use the root-mean-squared (RMS) distance to measure how far the walker goes, and run the simulation thousands of times to compare the simulated RMS values with theoretical ones.
Project 17: Predict the Flight of a Cannonball Employ the bisection numerical method to find the root of a nonlinear function in order to tackle the age-old problem of determining the correct firing angle for a cannonball.
Project 18: Design a Fountain with Water Jets Continue exploring the physics of projectiles by designing a multitier water fountain. Combine core Kotlin skills with advanced JavaFX techniques to generate and display the fountain’s structure and the water jets’ trajectories.
Project 19: Track a Pendulum’s Motion and Phase Leverage Newtonian laws of motion and gravity to calculate and plot a pendulum’s angular displacement and velocity along with its phase-space over time. Incorporate the impact of air drag to make the pendulum’s motion more realistic.

Project 20: The Physics of Coffee Cooling Create a Kotlin app that tackles a quintessential dilemma: Should you add cream to your coffee when you buy it at the coffee shop or when you get back to the office? Apply principles of Newtonian cooling to keep your coffee as warm as possible.

Project 21: Simulate a Binary Star System Animate the intricate dance of two stars orbiting each other. As time progresses, the stars gracefully trace their paths, allowing a delightful exploration of stellar dynamics.

Project 22: The “Hello, World!” of Fractals Learn the features of fractal geometry by drawing a series of concentric squares. Write your first recursive function and set its stopping condition.

Project 23: Draw the Sierpin´ski Triangle Realize a classic fractal pattern named after mathematician Wacław Sierpiński. Translate the pattern’s geometry into a codable strategy and make multiple recursive calls from within the same function.

Project 24: Create a Fractal Tree Develop a Kotlin program that draws a fractal tree, starting with a trunk and recursively generating smaller branches in opposite directions.

Project 25: Design an L-System Simulator Code an interactive L-system simulator from scratch, including a Kotlin implementation of Turtle Graphics. L-systems generate fractals using an alphabet of symbols, a starting axiom, and a set of rules defining how symbols are iteratively replaced.

Project 26: Code and Visualize the Mandelbrot Set Calculate and draw the Mandelbrot set, a captivating two-dimensional fractal defined in the complex plane. This mesmerizing image emerges from simple iterative rules and reveals intricate structures when magnified ad infinitum.

Project 27: Space-Efficient Sorting with Insertion Sort Explore the world of sorting algorithms and big O notation. Though it’s slower than other popular sorting methods, insertion sort operates in place, resulting in a low-space complexity.

Project 28: Faster Sorting with Merge Sort Implement merge sort, a speedy sorting algorithm that’s stable but less memory efficient than insertion sort. Recursively divide an array of values into smaller subarrays, sort them, and merge them back together.

Project 29: High-Efficiency Sorting with Quick Sort Code the quick sort algorithm, a fast and memory-efficient algorithm perfect for large datasets. Recursively select a pivot element in an array and divide the other elements into subarrays with values less than and greater than the pivot.

Project 30: Stack-Based Searching with Depth-First Search  Implement depth-first search (DFS), one of several algorithms for traversing or searching a graph data structure. Use a stack to explore each path to its fullest, and backtrack when a dead end is reached.

Project 31: Queue-Based Searching with Breadth-First Search Use a queue to realize the breadth-first search (BFS) algorithm. BFS explores all nodes at the current depth before moving on to nodes at the next level of depth.

Project 32: Heuristic Searching with A* Implement A*, an informed search algorithm that uses a heuristic function to guide its search. Given a weighted graph, a source node, and a goal node, A* finds the shortest path from the source to the goal.

Project 33: Evolve Gibberish into Shakespeare Use principles of heuristics and natural evolution to go from random strings to a famous line from Shakespeare. Develop modular, reusable code for the genetic algorithm, modeling genetic operators like elitism, selection, crossover, and mutation.

Project 34: Solve the Knapsack Problem Unleash your genetic algorithm code on the knapsack problem, one of a class of combinatorial optimization problems where the global optimal solution is notoriously hard to achieve.

Project 35: Optimize a Multivariate Function with the Genetic Algorithm Adapt the genetic algorithm to solve an optimization problem with a complex, multivariate, nondifferentiable mathematical function. Employ real-valued genes to represent the decision variables and locate the global optimal solution within a given decision space.

Project 36: Optimize a Multivariate Function with a Particle Swarm  Implement the particle swarm optimization (PSO) algorithm, a nature-inspired, agent-based method that seeks optimal solutions to complex problems by emulating swarm behavior. Write code that actively pursues continuous improvement through individual and collective learning.

Project 37: Solve the Traveling Salesman Problem with an Ant Colony System Use an ant colony system, another nature-inspired algorithm, to tackle Berlin52, a notoriously challenging optimization problem. Discover the optimal route through 52 stations in Berlin from among the astronomical 1.551119 × 10⁶⁶ distinct ways to arrange the tour.