Tasks

Complete the task of the chosen difficulty level for your variant number.

Variants

Variant 1. Calculator

1. Initial level. Create a standalone Kotlin/Compose desktop application "Calculator": a classic calculator with a button grid and history. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Calculator": a classic calculator with a button grid and history. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Calculator": a classic calculator with a button grid and history. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 2. Unit converter

1. Initial level. Create a standalone Kotlin/Compose desktop application "Unit converter": conversion with a choice of category and units. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Unit converter": conversion with a choice of category and units. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Unit converter": conversion with a choice of category and units. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 3. Shopping list

1. Initial level. Create a standalone Kotlin/Compose desktop application "Shopping list": adding, checking off, filters, and a total. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Shopping list": adding, checking off, filters, and a total. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Shopping list": adding, checking off, filters, and a total. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 4. Pomodoro timer

1. Initial level. Create a standalone Kotlin/Compose desktop application "Pomodoro timer": a circular progress indicator and settings. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Pomodoro timer": a circular progress indicator and settings. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Pomodoro timer": a circular progress indicator and settings. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 5. BMI calculator

1. Initial level. Create a standalone Kotlin/Compose desktop application "BMI calculator": a form with field validation and a scale. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "BMI calculator": a form with field validation and a scale. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "BMI calculator": a form with field validation and a scale. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 6. Tic-tac-toe

1. Initial level. Create a standalone Kotlin/Compose desktop application "Tic-tac-toe": a 3×3 board, determining the winner, and the score. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Tic-tac-toe": a 3×3 board, determining the winner, and the score. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Tic-tac-toe": a 3×3 board, determining the winner, and the score. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 7. Color mixer

1. Initial level. Create a standalone Kotlin/Compose desktop application "Color mixer": RGB sliders and a preview. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Color mixer": RGB sliders and a preview. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Color mixer": RGB sliders and a preview. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 8. Word cards

1. Initial level. Create a standalone Kotlin/Compose desktop application "Word cards": flipping cards and learning progress. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Word cards": flipping cards and learning progress. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Word cards": flipping cards and learning progress. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 9. Cafe menu

1. Initial level. Create a standalone Kotlin/Compose desktop application "Cafe menu": dish cards and an order cart. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Cafe menu": dish cards and an order cart. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Cafe menu": dish cards and an order cart. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 10. Calorie counter

1. Initial level. Create a standalone Kotlin/Compose desktop application "Calorie counter": adding foods and a daily total. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Calorie counter": adding foods and a daily total. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Calorie counter": adding foods and a daily total. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 11. Registration form

1. Initial level. Create a standalone Kotlin/Compose desktop application "Registration form": radio buttons, checkboxes, and a confirmation dialog. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Registration form": radio buttons, checkboxes, and a confirmation dialog. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Registration form": radio buttons, checkboxes, and a confirmation dialog. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 12. Memory game

1. Initial level. Create a standalone Kotlin/Compose desktop application "Memory game": pairs of cards in a grid and a move counter. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Memory game": pairs of cards in a grid and a move counter. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Memory game": pairs of cards in a grid and a move counter. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 13. Currency converter

1. Initial level. Create a standalone Kotlin/Compose desktop application "Currency converter": input fields, currency selection, and swapping. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Currency converter": input fields, currency selection, and swapping. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Currency converter": input fields, currency selection, and swapping. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 14. Weather forecast

1. Initial level. Create a standalone Kotlin/Compose desktop application "Weather forecast": day cards in a LazyRow from static data. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Weather forecast": day cards in a LazyRow from static data. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Weather forecast": day cards in a LazyRow from static data. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 15. Music player (mockup)

1. Initial level. Create a standalone Kotlin/Compose desktop application "Music player (mockup)": a playlist and playback controls. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Music player (mockup)": a playlist and playback controls. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Music player (mockup)": a playlist and playback controls. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 16. Quiz

1. Initial level. Create a standalone Kotlin/Compose desktop application "Quiz": questions, answer options, and a result. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Quiz": questions, answer options, and a result. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Quiz": questions, answer options, and a result. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 17. Loan calculator

1. Initial level. Create a standalone Kotlin/Compose desktop application "Loan calculator": sliders and a payment table. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Loan calculator": sliders and a payment table. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Loan calculator": sliders and a payment table. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 18. Minesweeper

1. Initial level. Create a standalone Kotlin/Compose desktop application "Minesweeper": a field of cells, opening cells, and flags. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Minesweeper": a field of cells, opening cells, and flags. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Minesweeper": a field of cells, opening cells, and flags. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 19. Habit tracker

1. Initial level. Create a standalone Kotlin/Compose desktop application "Habit tracker": a grid of weekdays and check marks. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Habit tracker": a grid of weekdays and check marks. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Habit tracker": a grid of weekdays and check marks. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 20. World clock

1. Initial level. Create a standalone Kotlin/Compose desktop application "World clock": time zones updated every second. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "World clock": time zones updated every second. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "World clock": time zones updated every second. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 21. Password generator

1. Initial level. Create a standalone Kotlin/Compose desktop application "Password generator": options set with switches and a strength estimate. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Password generator": options set with switches and a strength estimate. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Password generator": options set with switches and a strength estimate. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 22. Paint app

1. Initial level. Create a standalone Kotlin/Compose desktop application "Paint app": Canvas, drawing with the mouse, and color selection. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Paint app": Canvas, drawing with the mouse, and color selection. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Paint app": Canvas, drawing with the mouse, and color selection. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 23. Book catalog

1. Initial level. Create a standalone Kotlin/Compose desktop application "Book catalog": search and filters in a LazyColumn. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Book catalog": search and filters in a LazyColumn. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Book catalog": search and filters in a LazyColumn. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 24. 15 puzzle

1. Initial level. Create a standalone Kotlin/Compose desktop application "15 puzzle": moving tiles and checking for a win. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "15 puzzle": moving tiles and checking for a win. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "15 puzzle": moving tiles and checking for a win. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 25. Gradebook

1. Initial level. Create a standalone Kotlin/Compose desktop application "Gradebook": entering scores and colored grade indicators. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Gradebook": entering scores and colored grade indicators. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Gradebook": entering scores and colored grade indicators. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 26. Class timetable

1. Initial level. Create a standalone Kotlin/Compose desktop application "Class timetable": weekday tabs and class cards. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Class timetable": weekday tabs and class cards. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Class timetable": weekday tabs and class cards. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 27. Metronome

1. Initial level. Create a standalone Kotlin/Compose desktop application "Metronome": tempo selection and a beat animation. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Metronome": tempo selection and a beat animation. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Metronome": tempo selection and a beat animation. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 28. Contacts

1. Initial level. Create a standalone Kotlin/Compose desktop application "Contacts": a list with search and details in a dialog. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Contacts": a list with search and details in a dialog. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Contacts": a list with search and details in a dialog. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 29. Shape gallery

1. Initial level. Create a standalone Kotlin/Compose desktop application "Shape gallery": Canvas with shape parameters and areas. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Shape gallery": Canvas with shape parameters and areas. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Shape gallery": Canvas with shape parameters and areas. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Variant 30. Budget planner

1. Initial level. Create a standalone Kotlin/Compose desktop application "Budget planner": categories and spending progress bars. Implement one main action through a form with labeled fields and a button, and show the result on the same screen. Store the state with remember, mark invalid or empty input with a text error, and provide a reset.

2. Basic level. Create a standalone Kotlin/Compose desktop application "Budget planner": categories and spending progress bars. Implement the full scenario of the topic, a history of at least five actions in a LazyColumn or a grid with stable keys, a mode selection, and a dialog confirming clearing. Hoist the shared state and separate domain computations from the UI; Cancel does not change the history. Test a narrow window and keyboard input.

3. Advanced level. Create a standalone Kotlin/Compose desktop application "Budget planner": categories and spending progress bars. Implement the scenario of the topic, parameter editing, adaptive layout, accessible labels, and saving settings to a file. Provide the modes --help, --config=path, and --check=key:value,...: the last one checks the domain logic without a GUI and prints an aligned report with a total. Errors go to stderr, with codes 0/2/1 for success, input errors, and failure. On a normal launch, the GUI runs; add tests for validation, dialog cancellation, and state restoration.

Procedure

1. Sketch the form and define the owner of each piece of state.
2. Extract pure computation and validation functions.
3. Implement the layout for a narrow and a wide window.
4. Test empty input, numeric limits, and canceling a dialog.
5. Test keyboard focus and the behavior of effects after closing.
6. Show the tests of the domain logic and a repeatable UI scenario.