DEV Community: Ahnaf Ashique Adi

💻 Hacking the Grid: How I Built CypherCore with Amazon Q CLI

Ahnaf Ashique Adi — Fri, 23 May 2025 18:59:55 +0000

🧠 Introduction
I wanted to build something vibe-heavy, immersive, and original — a retro-futuristic hacking sim you’d expect inside a cyberpunk movie.

So I made CypherCore — a Matrix-style puzzle game created using Python, Pygame, and Amazon Q CLI, an AI-powered coding assistant from AWS.

CypherCore isn’t just another retro game. While many rebuild classics like Pong or Tetris, I set out to create something that felt like you were diving headfirst into a digital mainframe.

Built with Python, Pygame, and the generative power of Amazon Q CLI, CypherCore simulates hacking terminals with logic puzzles and glitch aesthetics — all made on a Hackintosh ThinkPad running macOS Monterey.

⚡️ The twist?
I built the entire thing using natural language prompts, on a Hackintosh ThinkPad running macOS. No fancy rig. Just vibes and AI

🎮 What Is CypherCore?

CypherCore is a puzzle game set inside a simulated mainframe. The aesthetics are straight out of 90s hacker lore: ASCII visuals, green-glow Matrix animations, glitch FX, and logic-based gameplay.

🔐 Game Highlights:
Hacker terminal UI with Matrix-style backgrounds
Four cyberpunk-themed levels:

Binary Maze – Grid navigation + timing
Logic Gate Puzzle – Unlock via AND/OR logic
Memory Decryption – Short-term memory challenge
Core Breach – Rhythm-based circuit tapping

Built using modular code generated and refined with Amazon Q CLI

Playable entirely via keyboard

⚙️ My Setup

💻 Device: ThinkPad T490 running macOS Monterey (Hackintosh)
🧠 AI Assistant: Amazon Q CLI
🐍 Language: Python 3.13+
🎮 Framework: Pygame
🧰 Tools: VS Code, Homebrew, GitHub

🔧 How I Installed Everything (on macOS)
Firstly we have to install python and pygame on macOS

brew install python
pip3 install pygame

Here pip3 can be found in python but for brew we have to install Homebrew first using the terminal.


/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

After downloading brew we now move forward to download Amazon's Q CLI as the AI Assistant using brew typing :


brew install amazon-q

After downloading amazon q we can check its version typing-


q --version

After getting the output we are ready to start prompting and making our game.But first we login to Q typing :

q login
q chat

After Amazon Q's chat session is turned on we can start by giving it a prompt and try to give life to your imagination.For my case I have made some small games using unity and unreal so I already had an structured idea of what I wanted to Prototype.So at first I prompted:

Build a Python game called "CypherCore" using only Python and Pygame.

Start with an animated ASCII intro in the terminal using a typewriter + glitch effect for the following logo:

      ___                       ___         ___           ___           ___           ___           ___           ___           ___     
     /  /\          ___        /  /\       /__/\         /  /\         /  /\         /  /\         /  /\         /  /\         /  /\    
    /  /:/         /__/|      /  /::\      \  \:\       /  /:/_       /  /::\       /  /:/        /  /::\       /  /::\       /  /:/_   
   /  /:/         |  |:|     /  /:/\:\      \__\:\     /  /:/ /\     /  /:/\:\     /  /:/        /  /:/\:\     /  /:/\:\     /  /:/ /\  
  /  /:/  ___     |  |:|    /  /:/~/:/  ___ /  /::\   /  /:/ /:/_   /  /:/~/:/    /  /:/  ___   /  /:/  \:\   /  /:/~/:/    /  /:/ /:/_ 
 /__/:/  /  /\  __|__|:|   /__/:/ /:/  /__/\  /:/\:\ /__/:/ /:/ /\ /__/:/ /:/___ /__/:/  /  /\ /__/:/ \__\:\ /__/:/ /:/___ /__/:/ /:/ /\
 \  \:\ /  /:/ /__/::::\   \  \:\/:/   \  \:\/:/__\/ \  \:\/:/ /:/ \  \:\/:::::/ \  \:\ /  /:/ \  \:\ /  /:/ \  \:\/:::::/ \  \:\/:/ /:/
  \  \:\  /:/     ~\~~\:\   \  \::/     \  \::/       \  \::/ /:/   \  \::/~~~~   \  \:\  /:/   \  \:\  /:/   \  \::/~~~~   \  \::/ /:/ 
   \  \:\/:/        \  \:\   \  \:\      \  \:\        \  \:\/:/     \  \:\        \  \:\/:/     \  \:\/:/     \  \:\        \  \:\/:/  
    \  \::/          \__\/    \  \:\      \  \:\        \  \::/       \  \:\        \  \::/       \  \::/       \  \:\        \  \::/   
     \__\/                     \__\/       \__\/         \__\/         \__\/         \__\/         \__\/         \__\/         \__\/    

After the intro, create a transition to a green Matrix-style raining code background using Pygame (CMatrix visual effect) as the main background layer.

Then present the player with a terminal-based binary maze puzzle (only 0s and 1s) using the `curses` library for better full-screen interactivity.

After solving the maze, switch back to Pygame where the player must solve a logic gate puzzle. They’ll input correct AND/OR combinations to unlock a digital lock and progress to the next level.

Requirements:
- Use Python standard libraries and Pygame only
- Modular, beginner-friendly code with comments
- Reusable classes for effects, levels, logic gates, and maze
- Support arrow keys and typing input where necessary
- Include basic sound effects and level transition effects

🔁 Prototype 1: Terminal Crash & Memory Overload

Issue: The ASCII logo was rendered in the terminal with print() in a loop, crashing the system due to memory overrun.

After almost like 10 min I got the cool looking prototype where the CypherCore is printed in the terminal in a loop and the window of the game being blank and a memory overload crashed the game.

Fix: Prompted Q CLI to use pygame.Surface and animated the text line-by-line with a typewriter effect in the game window.

After this Q thought for a while and helped to fix the issue making the new intro and the main menu in the game window as we can see here:

After the main menu was fixed I was able to see all the first levels created in the prototype.The initial levels generated was only 2 out of the 4 i theorized and those two are shown here :

But this was not the game I wanted so I rewrote the whole prompt to :

Create a Python game called "CypherCore" using only Pygame and Python standard libraries.

Overview:
"CypherCore" is a futuristic, cyberpunk-themed puzzle adventure game. It includes an animated ASCII intro, a dynamic Matrix-style background, 4 unique levels, background music, sound effects, and a hacker-inspired UI.

Requirements:

1. Intro Screen:
- Display the CypherCore ASCII logo in a Pygame window.
- Animate the logo with a typewriter effect and glitchy flicker.
- Play simple looped hacker-style music during the intro (e.g., synth pad).
- ASCII Art should appear in the Pygame window (not the terminal).

2. Matrix Background:
- After the intro, display a full-screen "CMatrix"-like effect.
- Rain down green characters in columns like the Matrix movie.
- Overlay UI and levels on top of this effect.

3. Levels (modularize using LevelManager):
- Level 1: Binary Maze
  - Maze made of 0s and 1s.
  - Move player with arrow keys.
  - Timer and highlighted correct path.

- Level 2: Logic Gate Puzzle
  - Nodes connected by logic gates (AND, OR, NOT).
  - Player clicks gates and inputs binary values to unlock.
  - Show feedback for correct/incorrect answers.

- Level 3: Memory Decryption
  - Grid of hidden memory sectors.
  - Show a hint pattern briefly, then hide.
  - Player must recall and decrypt sectors in correct order.

- Level 4: Core Breach Timing
  - Animated circuits rotate around a central core.
  - Tap in rhythm to unlock nodes without hitting traps.
  - Use sound cues for timing help.

4. Visual Style:
- Use cyberpunk colors (black, neon green, glitch red/blue).
- Neon glowing text and transitions.
- Futuristic fonts and smooth animations.

5. Audio:
- Loop background music (simple synth or ambient).
- Sounds for unlock, fail, success, and transitions.

6. Code Structure:
- Use clean classes and modules:
  - LevelManager: controls level transitions
  - MatrixEffect: handles dynamic background
  - Puzzle: base class for levels
  - AudioEngine: for music and sound effects
- Write beginner-friendly, well-commented code.

After the prompt was given it made the code in a very structured way.

** 📦 Project Structure**

CypherCore/
├── main.py
├── LICENSE
├── README.md
├── audio_engine.py
├── matrix_effect.py
├── level_manager.py 
└──  requirements.txt

So after a while q created a good file structure and very modular codes for all the part of the game and with improved UI and everything we got to see :

Even after getting the codes and the game running as we can see above that didn't mean it was completed it had lots off problems. Like :-

🔁 Prototype 2: Broken Countdown Timer & Static Background

Issue: Q CLI added a 60-second global timer affecting all levels.
Result: Levels would timeout before completion.
Fix: Refactored using LevelManager, giving each level its own timer.

To fix it a different prompt was given to handle the timer in a different way which fixed it.Other that that I have seen only some part of the game has sound but some doesn't this is a bug that I found but had little town to fix similar to the logic gate puzzle may have a bug sometimes when pressed it just assumes you are right. Other than that the game is playable.

🧠 My Experience with Amazon Q CLI

Using Amazon Q CLI for CypherCore felt like coding with a co-pilot that actually gets the vibe. Here’s what stood out:


- Speed: I didn’t waste time writing boilerplate. Q CLI handled that instantly—menus, classes, event loops—it filled in the blanks fast.
- Creative Fuel: Even when I had a clear idea, Q CLI threw in variations or reminded me of better patterns. Sometimes, it shifted my design for the better.
- Learning in Flow: Whether I blanked on syntax or wanted to structure something clean, Q CLI acted like a cheat sheet that explained itself. It’s great for devs leveling up.
- Problem Solving: When I hit logic walls—like managing level timers or handling broken audio modules—Q CLI gave solid fixes I could adapt fast.

Of course, it’s not magic. You have to be clear with prompts, and what it gives is often a launchpad—not the final product. But that’s the beauty of it. You’re not just using AI to code; you’re jamming with it.

🎮 Conclusion:

Building CypherCore wasn’t just about making a game — it was about pushing the limits of creativity with AI as a coding partner. Amazon Q CLI turned out to be way more than just a code generator; it became part of my process. From kickstarting ideas to solving logic puzzles in real time, it made the whole build faster, smoother, and honestly, way more fun.

The final result? A neon and purplish-drenched cyberpunk puzzle game made with Python and vibes — and proof that with the right tools, even wild ideas can turn into something real.

🛠 Want to Build Your Own?

If this sparked something in you, here’s what I recommend:
Try out Amazon Q CLI for your next game idea — just open the terminal, start a chat, and prompt it like you're explaining to a dev buddy.

Check out the Amazon Q CLI Game Challenge for step-by-step guidance, and maybe even score a free tee.
Here:- https://s12d.com/BGWQCLI

Use my journey as a reference — break things, fix them, and have fun doing it.

🧪 Source Code: GitHub – https://github.com/Ahnaf-Ashique-Adi/CypherCore

Game on, hacker. AI isn’t here to replace us — it’s here to amplify us. Tools like Amazon Q CLI don’t just spit out code; they collaborate. You bring the vision, the vibe, the weird ideas. AI helps you bring it to life — faster, cleaner, and sometimes in ways you wouldn’t have thought of alone.

Sure, it’s not perfect. You still have to debug, tweak, and stitch the pieces together. But that’s the beauty of it. It’s like pair-programming with a tireless assistant who’s always ready to throw ideas at you.

For me, CypherCore was a test — could I vibe-code an entire game with just prompts and imagination? Turns out, yes. And that’s just the beginning

Why Do We Need a Server ISO? Can’t We Make a Server Using a Desktop ISO?

Ahnaf Ashique Adi — Sat, 12 Oct 2024 12:07:10 +0000

Why Do We Need a Server ISO? Can’t We Make a Server Using a Desktop ISO?

Introduction

When embarking on the journey of setting up a server, one of the first questions that arise is whether to use a server or desktop ISO.
This topic is essential for anyone looking to create a robust server environment, especially for projects like personal cloud servers. In this blog post, I’ll explore the differences between Linux server and desktop versions and share my personal experience of setting up a Nextcloud server on an old Acer laptop running Ubuntu.

Linux Server vs. Desktop: What’s the Difference?

Purpose and Optimization

*Resource Usage: *

*Server ISO: * Designed to operate efficiently with minimal resources, making it ideal for hosting services. It often comes without a graphical user interface (GUI) by default, which helps conserve system resources.
*Desktop ISO: * Includes a GUI and a wide array of applications suited for general use, which may consume more resources. This can be unnecessary for a server setup.

*Software Packages: *

*Server ISO: * pre-installed packages focus on server functionalities (e.g., web servers, databases) and are optimized for performance and stability.
*Desktop ISO: * Comes with various applications and utilities aimed at end-user functionality, which might not be needed for a server.

*Maintenance and Updates: *

*Server ISO: * Typically receives updates that prioritize security and performance for server applications.
*Desktop ISO: * Updates can include features that are not relevant to a server environment, possibly introducing unnecessary complexities.

Flexibility and Usability

While the server ISO is tailored for server tasks, I found that the desktop version could effectively create a server environment. As someone who recently undertook this challenge, the familiarity of the desktop interface was invaluable. It allowed me to perform various tasks beyond mere server operations, turning my journey into a unique learning experience.

Conclusion on the Choice

Ultimately, the decision between a server and desktop ISO depends on the user's familiarity with Linux, the resources available, and the specific needs of the project. In many cases, particularly for personal projects, using a desktop ISO can be an excellent starting point.

Setting Up a Personal Nextcloud Server on Ubuntu (Desktop Version)

After deciding to use the desktop version of Ubuntu for my personal cloud server, I embarked on the following steps:

Step 1: Update Your System

I began by updating my system to ensure all packages were current. This is essential for security and performance.

sudo apt update
sudo apt upgrade

Step 2: Install Required Packages

Next, I installed the packages required for Nextcloud, including Apache, MySQL, and PHP.

sudo apt install apache2 mariadb-server php libapache2-mod-php php-mysql php-xml php-curl php-zip php-gd php-mbstring php-intl php-bcmath

Problem Encountered: PHP Compatibility Issues

Initially, I tried to install PHP 8.3, which Nextcloud does not support. This led to the error message:

This version of Nextcloud is not compatible with PHP>=8.3. You are currently running 8.3.6.

To resolve this, I researched the issue and discovered that Nextcloud requires PHP 8.1 or lower. I downgraded to PHP 8.1 by updating my package list and installing the correct version:

sudo apt install php8.1 libapache2-mod-php8.1 php8.1-mysql php8.1-xml php8.1-curl php8.1-zip php8.1-gd php8.1-mbstring php8.1-intl php8.1-bcmath

Step 3: Configure the Database

I secured my MariaDB installation and created a database for Nextcloud.

sudo mysql_secure_installation

After securing the installation, I created a database:

CREATE DATABASE nextcloud;
CREATE USER 'nextclouduser'@'localhost' IDENTIFIED BY 'your_password';
GRANT ALL PRIVILEGES ON nextcloud.* TO 'nextclouduser'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Note: Ensure you replace 'your_password' with a strong password.

Step 4: Download Nextcloud

I downloaded the latest version of Nextcloud from the official website and extracted it to the Apache web directory.


wget https://download.nextcloud.com/server/releases/nextcloud-x.y.z.zip
unzip nextcloud-x.y.z.zip
sudo mv nextcloud /var/www/html/

Step 5: Configure Apache

To serve Nextcloud, I created a new virtual host configuration file.

sudo nano /etc/apache2/sites-available/nextcloud.conf

I added the following configuration (replacing 1xx.xxx.x.x with your local IP):



<VirtualHost *:80>
    ServerName 1xx.xxx.x.x
    DocumentRoot /var/www/html/nextcloud

    <Directory /var/www/html/nextcloud>
        Options +FollowSymlinks
        AllowOverride All
        Require all granted
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/nextcloud_error.log
    CustomLog ${APACHE_LOG_DIR}/nextcloud_access.log combined
</VirtualHost>

After saving the file, I enabled the site and necessary Apache modules:



sudo a2ensite nextcloud
sudo a2enmod rewrite
sudo systemctl restart apache2

Step 6: Access Nextcloud

I accessed Nextcloud through my browser using the local IP address. Here, I was greeted by the Nextcloud setup page.

Step 7: Complete the Setup

On the setup page, I entered the database details and created an admin account. The installation took a few minutes. I was relieved to finally see the Nextcloud dashboard.

Step 8: Security Configuration

To enhance security, I attempted to configure SSL using Let's Encrypt. However, I encountered an issue when trying to obtain a certificate for my private IP address:

One or more of the entered domain names was not valid: 1xx.xxx.x.x

As Let's Encrypt does not issue certificates for bare IP addresses, I opted to create a self-signed certificate instead. This allows me to test the server securely without incurring costs. Here’s how I created a self-signed certificate:



sudo apt install openssl
sudo mkdir /etc/ssl/private
sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/ssl/private/selfsigned.key -out /etc/ssl/certs/selfsigned.crt

During this process, I filled in the details as prompted. For the Organizational Unit, since it’s a personal project, I simply used “Personal Project.”

Next, I updated the Apache configuration to use the self-signed certificate:



<VirtualHost *:443>
    ServerName 1xx.xxx.x.x
    DocumentRoot /var/www/html/nextcloud

    SSLEngine on
    SSLCertificateFile /etc/ssl/certs/selfsigned.crt
    SSLCertificateKeyFile /etc/ssl/private/selfsigned.key

    <Directory /var/www/html/nextcloud>
        Options +FollowSymlinks
        AllowOverride All
        Require all granted
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/nextcloud_error.log
    CustomLog ${APACHE_LOG_DIR}/nextcloud_access.log combined
</VirtualHost>

I then enabled the SSL module and restarted Apache:



sudo a2enmod ssl
sudo systemctl restart apache2

Step 9: Mounting the External SSD for Storage

To expand my storage capacity, I decided to mount an external SSD. This step was crucial for enhancing the storage capabilities of my Nextcloud server. I mounted the SSD by following these commands:

Identify the SSD:



sudo fdisk -l

*Create a mount point: *



sudo mkdir /mnt/nextcloud_data

*Mount the SSD: *



sudo mount /dev/sdX1 /mnt/nextcloud_data

(Replace /dev/sdX1 with your actual SSD identifier.)

To make the mount permanent, I added it to /etc/fstab:



echo '/dev/sdX1 /mnt/nextcloud_data ext4 defaults 0 2' | sudo tee -a /etc/fstab

Final Steps: Testing and Future Improvements

After completing the setup, I tested Nextcloud by uploading files and checking functionalities like sharing and collaboration. Everything worked smoothly!

Conclusion

Setting up a personal cloud server with Nextcloud on my Ubuntu laptop was a rewarding experience. Each challenge, from PHP compatibility issues to SSL certificate generation, provided valuable learning opportunities. Ultimately, this journey reinforced my technical skills and passion for exploring the possibilities within the Linux ecosystem.

By choosing the path less traveled—using a desktop ISO—I transformed an old laptop into a powerful cloud server, proving that with determination and adaptability, even the most daunting tasks can lead to remarkable achievement.