Which Programming Languages Are Used in CyberStrikeAI? A Complete Technical Breakdown

CyberStrikeAI is a multi-language AI-driven cybersecurity platform built with Go for the backend engine, JavaScript with HTML/CSS for the interactive web interface, YAML for external tool definitions, and Markdown for documentation.

CyberStrikeAI, maintained by Ed1s0nZ, employs a polyglot architecture to separate high-performance server operations from dynamic frontend experiences. Understanding which programming languages power CyberStrikeAI enables developers to navigate its modular codebase, extend its penetration testing capabilities, and integrate additional AI-driven security tools effectively.

Core Programming Languages in CyberStrikeAI

Go – The Backend Engine and API Server

The core server, business logic, agent management, database operations, and MCP (Multi-Client Protocol) implementation are written in Go. The primary application initialization occurs in internal/app/app.go, where the NewApp function instantiates the Gin HTTP router, applies recovery middleware, and registers API route groups.

func NewApp(cfg *config.Config) (*App, error) {
    router := gin.New()
    router.Use(gin.Recovery())

    // Register HTTP handlers
    api := router.Group("/api")
    {
        handler.RegisterVulnerability(api)
        handler.RegisterSkill(api)
        // …
    }

    return &App{router: router, cfg: cfg}, nil
}

Additional critical Go source files include cmd/server/main.go (the executable entry point that starts the HTTP server) and internal/mcp/server.go (implementing the MCP protocol for multi-client communication).

JavaScript – Real-Time Frontend Interactivity

The interactive web console relies on JavaScript to handle real-time terminals, skill dashboards, and UI routing. In web/static/js/terminal.js, the code establishes WebSocket connections to stream command output between the Go backend and the browser.

const socket = new WebSocket(`ws://${location.host}/ws/terminal`);
socket.addEventListener('message', ev => {
  const data = JSON.parse(ev.data);
  term.write(data.output);
});

term.onData(data => socket.send(JSON.stringify({input: data})));

This JavaScript implementation enables live terminal sessions without page refreshes, processing user input through term.onData and displaying server responses via socket.addEventListener.

HTML and CSS – UI Structure and Styling

The single-page application layout is defined in HTML templates under web/templates/, with index.html serving as the root container for Vue-based components. CSS handles the responsive styling, color schemes, and console aesthetics in web/static/css/style.css.

HTML structure from web/templates/index.html:

<div id="app">
  <router-view></router-view>
</div>
<script src="/static/js/app.js"></script>

Styling rules from web/static/css/style.css:

body {
  margin: 0;
  font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
  background-color: #f5f5f5;
}

YAML – External Tool Definitions and Configuration

CyberStrikeAI uses YAML to declaratively define external security tools and global application settings that the Go engine loads at runtime. These definitions specify executable commands, argument templates, and metadata for AI-assisted tool selection.

Tool definition from tools/nmap.yaml:

name: nmap
description: Network mapper
command: nmap
args:
  - "-sV"
  - "-p"
  - "{{port}}"

The root config.yaml contains global application parameters, while individual files in the tools/ directory define specific penetration testing utilities like Nmap.

Markdown – Documentation and Knowledge Base

Extensive Markdown documentation provides project overviews, API references, and penetration testing guides. The primary entry point is README.md, with additional knowledge-base articles stored under the knowledge_base/ directory.

Documentation excerpt from README.md:

# Cyber Strike AI

A modular AI‑assisted penetration testing platform built with Go and a Vue‑based web UI.

How the Languages Integrate in the Architecture

The Go backend serves as the central orchestrator, handling HTTP requests, managing WebSocket connections for the JavaScript frontend, parsing YAML tool definitions to execute system commands, and referencing Markdown documentation to provide context for AI models. This separation allows the platform to maintain high-performance concurrent operations while delivering a responsive, interactive user experience through modern web technologies.

Summary

• Go powers the backend server, API handlers, database layer, and MCP protocol implementation in internal/app/app.go and internal/mcp/server.go.
• JavaScript drives real-time terminal interactions and dashboard functionality via WebSocket connections in web/static/js/terminal.js.
• HTML and CSS provide the structural layout and visual styling for the web console, defined in web/templates/index.html and web/static/css/style.css.
• YAML configures external security tools and application settings, with tool definitions stored in files like tools/nmap.yaml and global config in config.yaml.
• Markdown documents the platform architecture, usage guides, and penetration testing knowledge in README.md and the knowledge_base/ folder.

Frequently Asked Questions

Is CyberStrikeAI written entirely in Go?

No. While the backend server, business logic, and MCP protocol are implemented in Go, the project utilizes JavaScript for frontend interactivity, HTML/CSS for the user interface, YAML for tool configuration, and Markdown for documentation. This multi-language approach separates concerns between server performance and user experience.

What frontend framework does CyberStrikeAI use?

The frontend utilizes vanilla JavaScript with WebSocket APIs for real-time communication, served through HTML templates and styled with custom CSS. According to the repository structure, the UI references Vue.js components (as noted in README.md), though core interactivity such as terminal handling is implemented in native JavaScript within web/static/js/terminal.js.

How does CyberStrikeAI define external security tools?

External tools are defined using YAML configuration files stored in the tools/ directory. Each YAML file specifies the tool name, description, executable command, and argument templates (including variable placeholders like {{port}}) that the Go backend parses and executes during security assessments.

Where is the main server entry point located?

The server initialization starts at cmd/server/main.go, which imports and calls the NewApp function from internal/app/app.go. This function configures the Gin HTTP router, registers vulnerability and skill handlers, and establishes the WebSocket endpoint for terminal communication before binding to the configured network port.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}