DEV Community: ABHISHEK PANDEY

SoulKing-AI

ABHISHEK PANDEY — Tue, 27 Oct 2026 05:46:24 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

💀🎸 SoulKing AI — Your Terminal. Your AI. Your Phantom.

What if your Linux terminal had a soul of its own?

Imagine opening your terminal late at night and finding a mysterious digital spirit waiting for you. It can explain Linux commands, analyze potentially dangerous operations, tell creepy stories, and help you explore your system.

Meet SoulKing AI, a haunted, terminal-based Linux assistant that combines local AI, practical Linux utilities, defensive security tools, and a spooky personality.

Built with Python, Rich, SQLite, and the Ollama API, SoulKing transforms the familiar Linux command line into an interactive experience inspired by the Ghost in the Machine theme.

But this ghost isn't completely dependent on the internet. Even when the local AI service is unavailable, SoulKing's built-in utilities and offline story generator can keep working.

Let's explore the machine! 👻

👻 What I Built

SoulKing AI is a terminal-based assistant designed for Kali Linux and other Linux distributions.

I wanted to create something that combines two ideas:

A spooky digital companion with a personality.
A practical Linux assistant that helps users understand their system and commands.

SoulKing includes three selectable personality modes:

💀 SoulKing Mode: A friendly, humorous, theatrical skeleton-musician spirit.
👻 Ghost Mode: A mysterious personality with spooky responses.
💻 Developer Mode: A technical assistant for Python, Java, Linux, Git, and debugging.

Beyond its personality, SoulKing includes system diagnostics, Linux command assistance, network utilities, command-risk analysis, local SQLite storage, and a ghost story generator.

The project is entirely terminal-based. There is no graphical application window or browser interface.

🖥️ Demo: Inside the Haunted Machine

Here are four screenshots of SoulKing AI running in the terminal.

💀 1. The Haunted Terminal Awakens

The first screen introduces SoulKing's identity through its ASCII banner, terminal prompt, system information, and startup greeting.

It also displays the current AI connection status and confirms that local SQLite memory has been initialized.

In this captured session, Ollama is offline. SoulKing clearly reports the unavailable service instead of pretending that the AI model is running.

That's an important part of the design: the application communicates its actual status to the user.

📜 2. A Command Reference for the Phantom

SoulKing includes a categorized command reference that helps users discover its capabilities.

The available commands cover several areas:

General application controls and configuration.
System information and diagnostics.
Linux command assistance.
Local AI model selection and conversations.
Network utilities.
Defensive security tools.
Ghost story generation.

Rather than requiring users to memorize everything, the help command provides a structured overview of the terminal assistant.

🛡️ 3. Command Risk Analyzer and Linux Assistance

This is one of SoulKing's most practical features.

The screenshot demonstrates the command:

risk rm -rf /tmp/example && suggest show listening network ports

SoulKing identifies the recursive deletion operation as high risk and explains why it can permanently remove files. It also suggests a safer alternative.

The command suggestion feature then proposes ss -tuln for displaying listening network ports.

Notice the important detail: the proposed command is never automatically executed.

The screenshot also demonstrates that SoulKing can provide built-in Linux assistance when the Ollama service is disconnected.

Static command analysis is a useful precaution, although it cannot guarantee that every command is safe. Users should always inspect commands and their arguments before running them.

👻 4. Ghost Stories from the Machine

Every haunted terminal needs a storyteller.

This screenshot demonstrates the command:

story short && sysinfo

SoulKing generates a short fictional horror story titled "The Violin in /dev/null".

The story imagines a strange event on a Linux server, where a corrupted core dump and a mysterious melody turn an ordinary system log into a miniature piece of digital horror.

The screenshot identifies the story source as the built-in offline archive because Ollama is disconnected.

After the story, SoulKing displays Linux system information, including the distribution, kernel, architecture, Python version, and working directory.

This is exactly the kind of experience I wanted: a terminal that remains useful while giving users something unexpected.

💻 Code

GitHub Repository: SoulKing-AI

The project is written in Python and released under the MIT License.

The repository contains the source code, terminal screenshots, tests, installation instructions, and configuration documentation.

I built SoulKing to be explored, customized, and extended by other developers.

⚙️ How I Built It

SoulKing uses a terminal-first architecture, keeping the command line as its entire interface.

Technology Stack

Python 3.11+: Core application logic and Linux utilities.
Rich: Terminal formatting, tables, and an enhanced command-line experience.
Ollama: Local model serving through its HTTP API.
Llama 3.2: An example open-weight model supported by the project.
SQLite: Local storage for conversations, command history, favorites, saved stories, and preferences.
TOML: Human-readable application configuration.

The application can also be configured to use another compatible installed model, such as Qwen2.5-Coder.

🧠 Local AI Integration

SoulKing connects to an Ollama service running locally on the machine.

When Ollama is available and a compatible model is installed, users can interact with the assistant through commands such as ask and can generate AI-powered stories.

The application checks the service's availability and reports when it cannot connect.

The screenshots show the offline state, where the built-in story archive and supported Linux assistance features continue to work.

🐧 Linux Utilities

SoulKing includes commands for:

Viewing CPU, memory, disk, and uptime information.
Listing running processes.
Explaining Linux commands and their flags.
Suggesting commands for natural-language tasks.
Inspecting file permissions.
Finding files.
Viewing network interfaces and connections.
Resolving DNS records and checking host reachability.
Analyzing local logs.
Checking URL patterns for suspicious characteristics.
Identifying installed security and networking tools.
Analyzing potentially dangerous command patterns.

The command-risk analyzer and other defensive utilities are designed to help users make more informed decisions when working in a Linux terminal.

📚 Local Memory

SoulKing uses SQLite to store application data, including conversations, messages, command history, favorite commands, saved stories, and preferences.

Users can disable conversation-history saving through the application's configuration.

This local-first approach gives users more control over their saved data.

🔓 Why Does Open Innovation Matter?

For me, open innovation is about having the freedom to experiment with AI, customize it, and run it on my own machine rather than making an entire project dependent on a closed API.

SoulKing uses Ollama to run compatible open-weight models locally.

Here is why that matters.

🔒 1. Privacy and Local Control

A Linux assistant may be used to discuss system configurations, examine logs, or troubleshoot a machine.

Running AI locally can help keep those prompts on the user's own computer rather than sending every request to a third-party AI provider.

SoulKing also stores its application history locally by default and provides an option to disable history saving.

📴 2. Offline Resilience

One of the most interesting things about SoulKing is that its core utilities do not all depend on the AI service.

As the screenshots demonstrate, the application can report that Ollama is unreachable while still providing built-in stories, system information, and supported command-analysis functionality.

Once the required software and model have been installed, local AI interactions can also work without an internet connection.

This makes the project useful even when a remote service is unavailable.

🧠 3. Freedom to Experiment

Using a local AI runtime allows developers to experiment with compatible models and customize the assistant's behavior.

SoulKing supports changing the selected model and switching between personality modes.

This flexibility makes it easier to explore different models, prompts, and approaches without redesigning the whole application around one proprietary provider.

💸 4. Fewer Dependencies on Paid APIs

Local inference avoids mandatory per-request fees from a hosted AI API.

It still requires computing resources, memory, electricity, and sufficient hardware for the chosen model, but it gives developers another way to experiment without relying on a paid inference service.

🔓 5. Keeping Projects Under Our Control

A project built entirely around a closed service can be affected by changes in availability, pricing, or access limits.

By using a local runtime and modular components, SoulKing gives developers more control over how their application evolves.

Open innovation is not just about using AI. It's about having the freedom to decide where it runs, how it behaves, and how it can be changed.

🤖 My Agent Session

I used AI-assisted development while building and refining SoulKing's architecture, terminal interactions, and features.

I'm also exploring DevRelay to document the development process for this challenge.

💀 The Spirit of It

"Even without a body, intelligence lives on. Yohohoho!"

The Ghost in the Machine theme made me think about the relationship between computers, memory, and personality.

A terminal is normally a place for commands, logs, and predictable output. SoulKing adds a fictional digital spirit that can tell stories, explain commands, and respond with a little theatrical mischief.

The most interesting part is that the atmosphere does not depend entirely on a live AI connection.

In the screenshots, Ollama is offline, yet SoulKing still tells a story about a mysterious violin in /dev/null.

That small moment captures the idea behind the project: a machine can still have character, even when one of its services goes silent.

The ghost is fictional, but the freedom to experiment with local AI and keep useful software running on our own machines is real.

Maybe the ghost isn't really in the machine.

Maybe it's in the code we choose to keep alive. 👻

🏆 Prize Categories

Thanks for checking out SoulKing AI!

If you enjoy Linux, open-source AI, terminal tools, or spooky software projects, I'd love to hear what you think.

Your terminal. Your AI. Your phantom. 💀🎸

CheckMate: An AI-Powered Chess Game Built with Java

ABHISHEK PANDEY — Tue, 20 Oct 2026 16:13:27 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

I built CheckMate, a GUI-based chess game developed in Java. It includes an AI opponent, allowing players to enjoy a chess match without needing another person to play with.

The goal is to make chess more accessible and convenient. Instead of arranging a match with someone else, players can launch the game, play at their own pace, and practice their chess skills whenever they want.

CheckMate brings together chess gameplay, a graphical interface, and AI-based opponent functionality in one project.

https://raw.githubusercontent.com/abhishekdpandey18/CheckMate-Java/refs/heads/main/Screenshots/png1.png

Demo

You can explore the source code and project here:

CheckMate – GitHub Repository

A gameplay video or screenshots can be added here to demonstrate the interface and AI opponent in action.

Code

The project is open source and available on GitHub:

View CheckMate on GitHub

Feel free to explore the code, learn from the implementation, and contribute improvements.

How I Built It

I developed CheckMate using Java, with a graphical chess interface and AI opponent functionality.

The project focuses on combining the core rules of chess with an interactive experience. The AI gives players an opponent to challenge, while the GUI makes it easier to interact with the board and play a game.

My development work brings together Java programming, chess logic, interface design, and AI-based gameplay.

Open-source note: The project is publicly available on GitHub, making its implementation accessible for learning and collaboration. The specific AI model or algorithm used can be documented here once its implementation is confirmed.

Why Does Open Innovation Matter?

Open innovation makes projects like CheckMate easier to explore, learn from, and improve collaboratively.

By sharing the source code, I give other developers an opportunity to understand how the game works, suggest improvements, and build upon the existing implementation.

Open development also gives me flexibility to experiment with different AI approaches rather than treating the game as a closed product.

My goal is to make the project accessible to chess enthusiasts and developers who want to learn about Java, game development, and AI.

The Lazy Payoff

Sometimes, the hardest part of playing chess is finding someone available for a match.

CheckMate makes that easier by providing an AI opponent whenever a player wants to play. There is no need to coordinate schedules or wait for another player.

Players can start a game, practice strategies, and improve at their own pace.

Less waiting, more chess! ♟️

My Agent Session

Optional: Add your DevRelay agent session here to show how you used your coding agent during development.

Prize Categories

Add the applicable partner prize categories specified on the official challenge page, if any.

CheckMate: An AI-Powered Chess Game Built with Java

ABHISHEK PANDEY — Fri, 16 Oct 2026 18:06:22 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

I built CheckMate, a Java-based chess game that lets players enjoy chess against an AI opponent through a graphical user interface.

CheckMate is designed for chess enthusiasts, students, and beginners who want to practise chess, enjoy a single-player experience, and challenge themselves against a computer opponent.

The idea is to make chess accessible and enjoyable while providing a project that developers can explore, learn from, and extend.

For students and casual players, CheckMate can provide a convenient way to practise without needing another person to play with. In the future, features such as difficulty levels, game analysis, and move suggestions could make it even more useful.

Demo

GitHub Repository: CheckMate – Java Chess Game

Here is a preview of the project:

A short gameplay video or additional screenshots can further demonstrate the chessboard, piece movements, and AI opponent.

Code

Explore the source code on GitHub:

♟️ CheckMate – View Source Code

The project contains components for chessboard management, move handling, and gameplay. The repository is available for developers who want to study the implementation, learn from the code, or contribute improvements.

How I Built It

I developed CheckMate using Java, separating the chess gameplay logic from the graphical interface.

The main components include:

Java: The programming language used to build the application.
Graphical User Interface: Provides the interface through which players interact with the chessboard.
Chess Engine: Handles board representation, piece movements, and chess rules.
AI Opponent: Enables players to compete against the computer.
GitHub: Hosts the source code and provides a foundation for further development.

The AI opponent is a key part of the project because it makes single-player chess possible. The specific algorithm and decision-making process can be explained further by referencing the actual AI implementation in the source code.

Why Does Open Innovation Matter?

Open innovation makes it easier for developers to learn from existing projects, share ideas, and build upon one another's work.

With CheckMate, other developers can explore the chess engine, experiment with AI strategies, improve the interface, and contribute new features. The project can also help students learn about Java, game development, algorithms, and AI-assisted gameplay.

An openly accessible codebase encourages collaboration and gives learners a practical example they can build upon instead of starting from scratch.

My goal is to continue improving CheckMate and make it a useful learning project for the chess and open-source communities.

My Agent Session

If applicable, I will add a link to my DevRelay session showing how an AI coding agent helped during development.

My First User

My next step is to share CheckMate with a chess enthusiast or student and ask them to try playing against the AI opponent.

I want to collect feedback on the gameplay experience, the AI's difficulty, and possible improvements. This feedback can help me prioritise future features and make the application more useful.

I will update this section with genuine feedback after someone has tested the game.

Prize Categories

I will select the applicable prize categories according to the official Hacktoberfest Open-Source AI Challenge requirements.

🌿 TrailBuddy AI

ABHISHEK PANDEY — Sat, 10 Oct 2026 17:39:18 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

🌿 TrailBuddy AI: Your Offline Companion for Exploring Nature

What I Built

TrailBuddy AI is an open-source AI-powered outdoor companion designed to help people spend less time staring at screens and more time exploring the world around them.

The idea is simple: technology should encourage us to experience nature, not distract us from it.

TrailBuddy helps users discover outdoor activities, complete nature challenges, and learn about their surroundings. From identifying plants to spotting birds and exploring nearby green spaces, it turns an ordinary walk into an opportunity to learn something new.

Key Features

🌱 Nature Missions: Generate fun challenges, such as identifying different leaves, observing birds, or exploring a garden.
🐦 Nature Discovery: Add AI-assisted bird and plant identification.
📵 Screen-Free Mode: Prepare a checklist before heading outside, then enjoy the adventure without constantly interacting with your phone.
🔒 Privacy-Friendly AI: Design the application to support local inference, keeping personal interactions on the user's device.
🧩 Flexible Models: Use an open-weight model that can be replaced or customized as the project evolves.

TrailBuddy is designed for nature lovers, students, families, hikers, and anyone looking for a reason to step away from their screens.

Demo

🚀 Live Demo: [Add your deployed application URL]

🎥 Video Demo: [Add your demo video URL]

The demo will show how a user generates a nature mission, prepares for an outdoor adventure, and uses the checklist to explore the world beyond the screen.

Code

💻 GitHub Repository: [Add your GitHub repository URL]

The goal is to make TrailBuddy accessible to other developers who want to experiment with open-source AI and build tools that encourage healthier relationships with technology.

How I Built It

TrailBuddy is designed around open-source AI rather than relying entirely on a proprietary AI API.

Planned Technology Stack

Python: Core application logic.
Streamlit: A simple, accessible user interface.
Ollama: Local model inference.
Qwen or Gemma: An open-weight language model for generating nature missions and answering questions.
SQLite: Local storage for saved missions and completed challenges.
Optional vision and audio models: For future plant identification and bird-call recognition.

The application can generate personalized outdoor missions based on a user's interests, available time, and experience level. The user can save a mission and take it outside rather than remaining on the screen.

Local inference is a key design goal. Once the necessary models and application resources are downloaded, supported features can work without an internet connection.

Why Does Open Innovation Matter?

Open innovation makes TrailBuddy more adaptable, accessible, and privacy-conscious.

1. Privacy by design

Local inference can keep personal conversations and saved missions on the user's device rather than requiring every interaction to be sent to an external AI provider.

2. Freedom to experiment

Open-weight models let developers compare models, customize prompts, and experiment with different approaches to nature education.

3. Reduced dependency

A modular architecture makes it easier to replace one model with another instead of building the entire application around a single proprietary service.

4. Accessibility

Running an appropriately sized model locally can reduce recurring API costs. After the required software and models have been downloaded, supported offline features can work without a paid inference API.

5. Technology that encourages real-world experiences

The most important part of TrailBuddy is not the chatbot. It is what happens after the chatbot finishes helping. Open AI gives us the flexibility to build a tool that prepares people for an outdoor experience and then gets out of the way.

My Agent Session

🛠️ DevRelay Agent Session: [Add your saved DevRelay session URL, if available]

I'll use this section to share the development process, including the prompts, implementation decisions, and experiments behind the project.

Prize Categories

[Add the applicable partner categories after checking the challenge rules.]

Final Thoughts

AI doesn't always need to keep us online.

Sometimes, the best use of AI is to help us close our laptops, step outside, notice the birds, explore a new path, and reconnect with the world around us.

Touch grass. Stay curious. Build in the open. 🌿