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

> Discover the programming languages powering CyberStrikeAI. Explore the technical breakdown of Go, JavaScript, YAML, and Markdown used in this AI-driven cybersecurity platform.

- Repository: [公明/CyberStrikeAI](https://github.com/Ed1s0nZ/CyberStrikeAI)
- Tags: deep-dive
- Published: 2026-03-09

---

**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`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/internal/app/app.go), where the `NewApp` function instantiates the Gin HTTP router, applies recovery middleware, and registers API route groups.

```go
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`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/cmd/server/main.go) (the executable entry point that starts the HTTP server) and [`internal/mcp/server.go`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/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`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/web/static/js/terminal.js), the code establishes WebSocket connections to stream command output between the Go backend and the browser.

```javascript
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`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/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`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/web/static/css/style.css).

HTML structure from [`web/templates/index.html`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/web/templates/index.html):

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

```

Styling rules from [`web/static/css/style.css`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/web/static/css/style.css):

```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`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/tools/nmap.yaml):

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

```

The root [`config.yaml`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/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`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/README.md), with additional knowledge-base articles stored under the `knowledge_base/` directory.

Documentation excerpt from [`README.md`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/README.md):

```markdown

# 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`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/internal/app/app.go) and [`internal/mcp/server.go`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/internal/mcp/server.go).
- **JavaScript** drives real-time terminal interactions and dashboard functionality via WebSocket connections in [`web/static/js/terminal.js`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/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`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/web/templates/index.html) and [`web/static/css/style.css`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/web/static/css/style.css).
- **YAML** configures external security tools and application settings, with tool definitions stored in files like [`tools/nmap.yaml`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/tools/nmap.yaml) and global config in [`config.yaml`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/config.yaml).
- **Markdown** documents the platform architecture, usage guides, and penetration testing knowledge in [`README.md`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/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`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/README.md)), though core interactivity such as terminal handling is implemented in native JavaScript within [`web/static/js/terminal.js`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/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`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/cmd/server/main.go), which imports and calls the `NewApp` function from [`internal/app/app.go`](https://github.com/Ed1s0nZ/CyberStrikeAI/blob/main/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.